//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Omics service.
///
/// Amazon Web Services HealthOmics is a service that helps users such as bioinformaticians, researchers, and scientists to store, query, analyze, and generate insights from genomics and other biological data. It simplifies and accelerates the process of storing and analyzing genomic information for Amazon Web Services. For an introduction to the service, see What is Amazon Web Services HealthOmics? in the Amazon Web Services HealthOmics User Guide.
public struct Omics: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Omics client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Omics",
            serviceIdentifier: "omics",
            serviceProtocol: .restjson,
            apiVersion: "2022-11-28",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            variantEndpoints: Self.variantEndpoints,
            errorType: OmicsErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "ap-southeast-1": "omics.ap-southeast-1.amazonaws.com",
        "eu-central-1": "omics.eu-central-1.amazonaws.com",
        "eu-west-1": "omics.eu-west-1.amazonaws.com",
        "eu-west-2": "omics.eu-west-2.amazonaws.com",
        "il-central-1": "omics.il-central-1.amazonaws.com",
        "us-east-1": "omics.us-east-1.amazonaws.com",
        "us-west-2": "omics.us-west-2.amazonaws.com"
    ]}


    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "us-east-1": "omics-fips.us-east-1.amazonaws.com",
            "us-west-2": "omics-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Stops a multipart read set upload into a sequence store and returns a response with no body if the operation is successful. To confirm that a multipart read set upload has been stopped, use the ListMultipartReadSetUploads API operation to view all active multipart read set uploads.
    @Sendable
    @inlinable
    public func abortMultipartReadSetUpload(_ input: AbortMultipartReadSetUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AbortMultipartReadSetUploadResponse {
        try await self.client.execute(
            operation: "AbortMultipartReadSetUpload", 
            path: "/sequencestore/{sequenceStoreId}/upload/{uploadId}/abort", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Stops a multipart read set upload into a sequence store and returns a response with no body if the operation is successful. To confirm that a multipart read set upload has been stopped, use the ListMultipartReadSetUploads API operation to view all active multipart read set uploads.
    ///
    /// Parameters:
    ///   - sequenceStoreId: The sequence store ID for the store involved in the multipart upload.
    ///   - uploadId: The ID for the multipart upload.
    ///   - logger: Logger use during operation
    @inlinable
    public func abortMultipartReadSetUpload(
        sequenceStoreId: String,
        uploadId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AbortMultipartReadSetUploadResponse {
        let input = AbortMultipartReadSetUploadRequest(
            sequenceStoreId: sequenceStoreId, 
            uploadId: uploadId
        )
        return try await self.abortMultipartReadSetUpload(input, logger: logger)
    }

    /// Accept a resource share request.
    @Sendable
    @inlinable
    public func acceptShare(_ input: AcceptShareRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AcceptShareResponse {
        try await self.client.execute(
            operation: "AcceptShare", 
            path: "/share/{shareId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Accept a resource share request.
    ///
    /// Parameters:
    ///   - shareId: The ID of the resource share.
    ///   - logger: Logger use during operation
    @inlinable
    public func acceptShare(
        shareId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AcceptShareResponse {
        let input = AcceptShareRequest(
            shareId: shareId
        )
        return try await self.acceptShare(input, logger: logger)
    }

    /// Deletes one or more read sets. If the operation is successful, it returns a response with no body. If there is an error with deleting one of the read sets, the operation returns an error list. If the operation successfully deletes only a subset of files, it will return an error list for the remaining files that fail to be deleted. There is a limit of 100 read sets that can be deleted in each BatchDeleteReadSet API call.
    @Sendable
    @inlinable
    public func batchDeleteReadSet(_ input: BatchDeleteReadSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDeleteReadSetResponse {
        try await self.client.execute(
            operation: "BatchDeleteReadSet", 
            path: "/sequencestore/{sequenceStoreId}/readset/batch/delete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Deletes one or more read sets. If the operation is successful, it returns a response with no body. If there is an error with deleting one of the read sets, the operation returns an error list. If the operation successfully deletes only a subset of files, it will return an error list for the remaining files that fail to be deleted. There is a limit of 100 read sets that can be deleted in each BatchDeleteReadSet API call.
    ///
    /// Parameters:
    ///   - ids: The read sets' IDs.
    ///   - sequenceStoreId: The read sets' sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDeleteReadSet(
        ids: [String],
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDeleteReadSetResponse {
        let input = BatchDeleteReadSetRequest(
            ids: ids, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.batchDeleteReadSet(input, logger: logger)
    }

    /// Cancels an annotation import job.
    @Sendable
    @inlinable
    public func cancelAnnotationImportJob(_ input: CancelAnnotationImportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelAnnotationImportResponse {
        try await self.client.execute(
            operation: "CancelAnnotationImportJob", 
            path: "/import/annotation/{jobId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Cancels an annotation import job.
    ///
    /// Parameters:
    ///   - jobId: The job's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelAnnotationImportJob(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelAnnotationImportResponse {
        let input = CancelAnnotationImportRequest(
            jobId: jobId
        )
        return try await self.cancelAnnotationImportJob(input, logger: logger)
    }

    /// Cancels a run using its ID and returns a response with no body if the operation is successful. To confirm that the run has been cancelled, use the ListRuns API operation to check that it is no longer listed.
    @Sendable
    @inlinable
    public func cancelRun(_ input: CancelRunRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "CancelRun", 
            path: "/run/{id}/cancel", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Cancels a run using its ID and returns a response with no body if the operation is successful. To confirm that the run has been cancelled, use the ListRuns API operation to check that it is no longer listed.
    ///
    /// Parameters:
    ///   - id: The run's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelRun(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = CancelRunRequest(
            id: id
        )
        return try await self.cancelRun(input, logger: logger)
    }

    /// Cancels a variant import job.
    @Sendable
    @inlinable
    public func cancelVariantImportJob(_ input: CancelVariantImportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelVariantImportResponse {
        try await self.client.execute(
            operation: "CancelVariantImportJob", 
            path: "/import/variant/{jobId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Cancels a variant import job.
    ///
    /// Parameters:
    ///   - jobId: The job's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelVariantImportJob(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelVariantImportResponse {
        let input = CancelVariantImportRequest(
            jobId: jobId
        )
        return try await self.cancelVariantImportJob(input, logger: logger)
    }

    /// Completes a multipart read set upload into a sequence store after you have initiated the upload process with CreateMultipartReadSetUpload and uploaded all read set parts using UploadReadSetPart. You must specify the parts you uploaded using the parts parameter. If the operation is successful, it returns the read set ID(s) of the uploaded read set(s). For more information, see Direct upload to a sequence store in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func completeMultipartReadSetUpload(_ input: CompleteMultipartReadSetUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CompleteMultipartReadSetUploadResponse {
        try await self.client.execute(
            operation: "CompleteMultipartReadSetUpload", 
            path: "/sequencestore/{sequenceStoreId}/upload/{uploadId}/complete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "storage-", 
            logger: logger
        )
    }
    /// Completes a multipart read set upload into a sequence store after you have initiated the upload process with CreateMultipartReadSetUpload and uploaded all read set parts using UploadReadSetPart. You must specify the parts you uploaded using the parts parameter. If the operation is successful, it returns the read set ID(s) of the uploaded read set(s). For more information, see Direct upload to a sequence store in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - parts: The individual uploads or parts of a multipart upload.
    ///   - sequenceStoreId: The sequence store ID for the store involved in the multipart upload.
    ///   - uploadId: The ID for the multipart upload.
    ///   - logger: Logger use during operation
    @inlinable
    public func completeMultipartReadSetUpload(
        parts: [CompleteReadSetUploadPartListItem],
        sequenceStoreId: String,
        uploadId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CompleteMultipartReadSetUploadResponse {
        let input = CompleteMultipartReadSetUploadRequest(
            parts: parts, 
            sequenceStoreId: sequenceStoreId, 
            uploadId: uploadId
        )
        return try await self.completeMultipartReadSetUpload(input, logger: logger)
    }

    /// Creates an annotation store.
    @Sendable
    @inlinable
    public func createAnnotationStore(_ input: CreateAnnotationStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAnnotationStoreResponse {
        try await self.client.execute(
            operation: "CreateAnnotationStore", 
            path: "/annotationStore", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Creates an annotation store.
    ///
    /// Parameters:
    ///   - description: A description for the store.
    ///   - name: A name for the store.
    ///   - reference: The genome reference for the store's annotations.
    ///   - sseConfig: Server-side encryption (SSE) settings for the store.
    ///   - storeFormat: The annotation file format of the store.
    ///   - storeOptions: File parsing options for the annotation store.
    ///   - tags: Tags for the store.
    ///   - versionName:  The name given to an annotation store version to distinguish it from other versions.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAnnotationStore(
        description: String? = nil,
        name: String? = nil,
        reference: ReferenceItem? = nil,
        sseConfig: SseConfig? = nil,
        storeFormat: StoreFormat,
        storeOptions: StoreOptions? = nil,
        tags: [String: String]? = nil,
        versionName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAnnotationStoreResponse {
        let input = CreateAnnotationStoreRequest(
            description: description, 
            name: name, 
            reference: reference, 
            sseConfig: sseConfig, 
            storeFormat: storeFormat, 
            storeOptions: storeOptions, 
            tags: tags, 
            versionName: versionName
        )
        return try await self.createAnnotationStore(input, logger: logger)
    }

    ///  Creates a new version of an annotation store.
    @Sendable
    @inlinable
    public func createAnnotationStoreVersion(_ input: CreateAnnotationStoreVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAnnotationStoreVersionResponse {
        try await self.client.execute(
            operation: "CreateAnnotationStoreVersion", 
            path: "/annotationStore/{name}/version", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    ///  Creates a new version of an annotation store.
    ///
    /// Parameters:
    ///   - description:  The description of an annotation store version.
    ///   - name:  The name of an annotation store version from which versions are being created.
    ///   - tags:  Any tags added to annotation store version.
    ///   - versionName:  The name given to an annotation store version to distinguish it from other versions.
    ///   - versionOptions:  The options for an annotation store version.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAnnotationStoreVersion(
        description: String? = nil,
        name: String,
        tags: [String: String]? = nil,
        versionName: String,
        versionOptions: VersionOptions? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAnnotationStoreVersionResponse {
        let input = CreateAnnotationStoreVersionRequest(
            description: description, 
            name: name, 
            tags: tags, 
            versionName: versionName, 
            versionOptions: versionOptions
        )
        return try await self.createAnnotationStoreVersion(input, logger: logger)
    }

    /// Initiates a multipart read set upload for uploading partitioned source files into a sequence store. You can directly import source files from an EC2 instance and other local compute, or from an S3 bucket. To separate these source files into parts, use the split operation. Each part cannot be larger than 100 MB. If the operation is successful, it provides an uploadId which is required by the UploadReadSetPart API operation to upload parts into a sequence store. To continue uploading a multipart read set into your sequence store, you must use the UploadReadSetPart API operation to upload each part individually following the steps below:   Specify the uploadId obtained from the previous call to CreateMultipartReadSetUpload.   Upload parts for that uploadId.   When you have finished uploading parts, use the CompleteMultipartReadSetUpload API to complete the multipart read set upload and to retrieve the final read set IDs in the response. To learn more about creating parts and the split operation, see Direct upload to a sequence store in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func createMultipartReadSetUpload(_ input: CreateMultipartReadSetUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMultipartReadSetUploadResponse {
        try await self.client.execute(
            operation: "CreateMultipartReadSetUpload", 
            path: "/sequencestore/{sequenceStoreId}/upload", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Initiates a multipart read set upload for uploading partitioned source files into a sequence store. You can directly import source files from an EC2 instance and other local compute, or from an S3 bucket. To separate these source files into parts, use the split operation. Each part cannot be larger than 100 MB. If the operation is successful, it provides an uploadId which is required by the UploadReadSetPart API operation to upload parts into a sequence store. To continue uploading a multipart read set into your sequence store, you must use the UploadReadSetPart API operation to upload each part individually following the steps below:   Specify the uploadId obtained from the previous call to CreateMultipartReadSetUpload.   Upload parts for that uploadId.   When you have finished uploading parts, use the CompleteMultipartReadSetUpload API to complete the multipart read set upload and to retrieve the final read set IDs in the response. To learn more about creating parts and the split operation, see Direct upload to a sequence store in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token that can be used to avoid triggering multiple multipart uploads.
    ///   - description: The description of the read set.
    ///   - generatedFrom: Where the source originated.
    ///   - name: The name of the read set.
    ///   - referenceArn: The ARN of the reference.
    ///   - sampleId: The source's sample ID.
    ///   - sequenceStoreId: The sequence store ID for the store that is the destination of the multipart uploads.
    ///   - sourceFileType: The type of file being uploaded.
    ///   - subjectId: The source's subject ID.
    ///   - tags: Any tags to add to the read set.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMultipartReadSetUpload(
        clientToken: String? = nil,
        description: String? = nil,
        generatedFrom: String? = nil,
        name: String,
        referenceArn: String? = nil,
        sampleId: String,
        sequenceStoreId: String,
        sourceFileType: FileType,
        subjectId: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMultipartReadSetUploadResponse {
        let input = CreateMultipartReadSetUploadRequest(
            clientToken: clientToken, 
            description: description, 
            generatedFrom: generatedFrom, 
            name: name, 
            referenceArn: referenceArn, 
            sampleId: sampleId, 
            sequenceStoreId: sequenceStoreId, 
            sourceFileType: sourceFileType, 
            subjectId: subjectId, 
            tags: tags
        )
        return try await self.createMultipartReadSetUpload(input, logger: logger)
    }

    /// Creates a reference store and returns metadata in JSON format. Reference stores are used to store reference genomes in FASTA format. A reference store is created when the first reference genome is imported. To import additional reference genomes from an Amazon S3 bucket, use the StartReferenceImportJob API operation.  For more information, see Creating a HealthOmics reference store in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func createReferenceStore(_ input: CreateReferenceStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateReferenceStoreResponse {
        try await self.client.execute(
            operation: "CreateReferenceStore", 
            path: "/referencestore", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Creates a reference store and returns metadata in JSON format. Reference stores are used to store reference genomes in FASTA format. A reference store is created when the first reference genome is imported. To import additional reference genomes from an Amazon S3 bucket, use the StartReferenceImportJob API operation.  For more information, see Creating a HealthOmics reference store in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - clientToken: To ensure that requests don't run multiple times, specify a unique token for each request.
    ///   - description: A description for the store.
    ///   - name: A name for the store.
    ///   - sseConfig: Server-side encryption (SSE) settings for the store.
    ///   - tags: Tags for the store.
    ///   - logger: Logger use during operation
    @inlinable
    public func createReferenceStore(
        clientToken: String? = nil,
        description: String? = nil,
        name: String,
        sseConfig: SseConfig? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateReferenceStoreResponse {
        let input = CreateReferenceStoreRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            sseConfig: sseConfig, 
            tags: tags
        )
        return try await self.createReferenceStore(input, logger: logger)
    }

    /// Creates a run cache to store and reference task outputs from completed private runs. Specify an Amazon S3 location where Amazon Web Services HealthOmics saves the cached data. This data must be immediately accessible and not in an archived state. You can save intermediate task files to a run cache if they are declared as task outputs in the workflow definition file. For more information, see Call caching and Creating a run cache in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func createRunCache(_ input: CreateRunCacheRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRunCacheResponse {
        try await self.client.execute(
            operation: "CreateRunCache", 
            path: "/runCache", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Creates a run cache to store and reference task outputs from completed private runs. Specify an Amazon S3 location where Amazon Web Services HealthOmics saves the cached data. This data must be immediately accessible and not in an archived state. You can save intermediate task files to a run cache if they are declared as task outputs in the workflow definition file. For more information, see Call caching and Creating a run cache in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - cacheBehavior: Default cache behavior for runs that use this cache. Supported values are:  CACHE_ON_FAILURE: Caches task outputs from completed tasks for runs that fail. This setting is useful if you're debugging a workflow that fails after several tasks completed successfully. The subsequent run uses the cache outputs for previously-completed tasks if the task definition, inputs, and container in ECR are identical to the prior run.  CACHE_ALWAYS: Caches task outputs from completed tasks for all runs. This setting is useful in development mode, but do not use it in a production setting. If you don't specify a value, the default behavior is CACHE_ON_FAILURE. When you start a run that uses this cache, you can override the default cache behavior. For more information, see Run cache behavior in the Amazon Web Services HealthOmics User Guide.
    ///   - cacheBucketOwnerId: The Amazon Web Services account ID of the expected owner of the S3 bucket for the run cache. If not provided, your account ID is set as the owner of the bucket.
    ///   - cacheS3Location: Specify the S3 location for storing the cached task outputs. This data must be immediately accessible (not in an archived state).
    ///   - description: Enter a description of the run cache.
    ///   - name: Enter a user-friendly name for the run cache.
    ///   - requestId: A unique request token, to ensure idempotency. If you don't specify a token, Amazon Web Services HealthOmics automatically generates a universally unique identifier (UUID) for the request.
    ///   - tags: Specify one or more tags to associate with this run cache.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRunCache(
        cacheBehavior: CacheBehavior? = nil,
        cacheBucketOwnerId: String? = nil,
        cacheS3Location: String,
        description: String? = nil,
        name: String? = nil,
        requestId: String = CreateRunCacheRequest.idempotencyToken(),
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRunCacheResponse {
        let input = CreateRunCacheRequest(
            cacheBehavior: cacheBehavior, 
            cacheBucketOwnerId: cacheBucketOwnerId, 
            cacheS3Location: cacheS3Location, 
            description: description, 
            name: name, 
            requestId: requestId, 
            tags: tags
        )
        return try await self.createRunCache(input, logger: logger)
    }

    /// Creates a run group to limit the compute resources for the runs that are added to the group. Returns an ARN, ID, and tags for the run group.
    @Sendable
    @inlinable
    public func createRunGroup(_ input: CreateRunGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRunGroupResponse {
        try await self.client.execute(
            operation: "CreateRunGroup", 
            path: "/runGroup", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Creates a run group to limit the compute resources for the runs that are added to the group. Returns an ARN, ID, and tags for the run group.
    ///
    /// Parameters:
    ///   - maxCpus: The maximum number of CPUs that can run concurrently across all active runs in the run group.
    ///   - maxDuration: The maximum time for each run (in minutes). If a run exceeds the maximum run time, the run fails automatically.
    ///   - maxGpus: The maximum number of GPUs that can run concurrently across all active runs in the run group.
    ///   - maxRuns: The maximum number of runs that can be running at the same time.
    ///   - name: A name for the group.
    ///   - requestId: To ensure that requests don't run multiple times, specify a unique ID for each request.
    ///   - tags: Tags for the group.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRunGroup(
        maxCpus: Int? = nil,
        maxDuration: Int? = nil,
        maxGpus: Int? = nil,
        maxRuns: Int? = nil,
        name: String? = nil,
        requestId: String = CreateRunGroupRequest.idempotencyToken(),
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRunGroupResponse {
        let input = CreateRunGroupRequest(
            maxCpus: maxCpus, 
            maxDuration: maxDuration, 
            maxGpus: maxGpus, 
            maxRuns: maxRuns, 
            name: name, 
            requestId: requestId, 
            tags: tags
        )
        return try await self.createRunGroup(input, logger: logger)
    }

    /// Creates a sequence store and returns its metadata. Sequence stores are used to store sequence data files called read sets that are saved in FASTQ, BAM, uBAM, or CRAM formats. For aligned formats (BAM and CRAM), a sequence store can only use one reference genome. For unaligned formats (FASTQ and uBAM), a reference genome is not required. You can create multiple sequence stores per region per account.  The following are optional parameters you can specify for your sequence store:   Use s3AccessConfig to configure your sequence store with S3 access logs (recommended).   Use sseConfig to define your own KMS key for encryption.   Use eTagAlgorithmFamily to define which algorithm to use for the HealthOmics eTag on objects.   Use fallbackLocation to define a backup location for storing files that have failed a direct upload.   Use propagatedSetLevelTags to configure tags that propagate to all objects in your store.   For more information, see Creating a HealthOmics sequence store in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func createSequenceStore(_ input: CreateSequenceStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSequenceStoreResponse {
        try await self.client.execute(
            operation: "CreateSequenceStore", 
            path: "/sequencestore", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Creates a sequence store and returns its metadata. Sequence stores are used to store sequence data files called read sets that are saved in FASTQ, BAM, uBAM, or CRAM formats. For aligned formats (BAM and CRAM), a sequence store can only use one reference genome. For unaligned formats (FASTQ and uBAM), a reference genome is not required. You can create multiple sequence stores per region per account.  The following are optional parameters you can specify for your sequence store:   Use s3AccessConfig to configure your sequence store with S3 access logs (recommended).   Use sseConfig to define your own KMS key for encryption.   Use eTagAlgorithmFamily to define which algorithm to use for the HealthOmics eTag on objects.   Use fallbackLocation to define a backup location for storing files that have failed a direct upload.   Use propagatedSetLevelTags to configure tags that propagate to all objects in your store.   For more information, see Creating a HealthOmics sequence store in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token used to dedupe retry requests so that duplicate runs are not created.
    ///   - description: A description for the store.
    ///   - eTagAlgorithmFamily: The ETag algorithm family to use for ingested read sets. The default value is MD5up. For more information on ETags, see ETags and data provenance in the Amazon Web Services HealthOmics User Guide.
    ///   - fallbackLocation: An S3 location that is used to store files that have failed a direct upload. You can add or change the fallbackLocation after creating a sequence store. This is not required if you are uploading files from a different S3 bucket.
    ///   - name: A name for the store.
    ///   - propagatedSetLevelTags: The tags keys to propagate to the S3 objects associated with read sets in the sequence store. These tags can be used as input to add metadata to your read sets.
    ///   - s3AccessConfig: S3 access configuration parameters. This specifies the parameters needed to access logs stored in S3 buckets. The S3 bucket must be in the same region and account as the sequence store.
    ///   - sseConfig: Server-side encryption (SSE) settings for the store.
    ///   - tags: Tags for the store. You can configure up to 50 tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSequenceStore(
        clientToken: String? = CreateSequenceStoreRequest.idempotencyToken(),
        description: String? = nil,
        eTagAlgorithmFamily: ETagAlgorithmFamily? = nil,
        fallbackLocation: String? = nil,
        name: String,
        propagatedSetLevelTags: [String]? = nil,
        s3AccessConfig: S3AccessConfig? = nil,
        sseConfig: SseConfig? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSequenceStoreResponse {
        let input = CreateSequenceStoreRequest(
            clientToken: clientToken, 
            description: description, 
            eTagAlgorithmFamily: eTagAlgorithmFamily, 
            fallbackLocation: fallbackLocation, 
            name: name, 
            propagatedSetLevelTags: propagatedSetLevelTags, 
            s3AccessConfig: s3AccessConfig, 
            sseConfig: sseConfig, 
            tags: tags
        )
        return try await self.createSequenceStore(input, logger: logger)
    }

    /// Creates a cross-account shared resource. The resource owner makes an offer to share the resource with the principal subscriber (an AWS user with a different account than the resource owner). The following resources support cross-account sharing:   HealthOmics variant stores   HealthOmics annotation stores   Private workflows
    @Sendable
    @inlinable
    public func createShare(_ input: CreateShareRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateShareResponse {
        try await self.client.execute(
            operation: "CreateShare", 
            path: "/share", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Creates a cross-account shared resource. The resource owner makes an offer to share the resource with the principal subscriber (an AWS user with a different account than the resource owner). The following resources support cross-account sharing:   HealthOmics variant stores   HealthOmics annotation stores   Private workflows
    ///
    /// Parameters:
    ///   - principalSubscriber: The principal subscriber is the account being offered shared access to the resource.
    ///   - resourceArn: The ARN of the resource to be shared.
    ///   - shareName: A name that the owner defines for the share.
    ///   - logger: Logger use during operation
    @inlinable
    public func createShare(
        principalSubscriber: String,
        resourceArn: String,
        shareName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateShareResponse {
        let input = CreateShareRequest(
            principalSubscriber: principalSubscriber, 
            resourceArn: resourceArn, 
            shareName: shareName
        )
        return try await self.createShare(input, logger: logger)
    }

    /// Creates a variant store.
    @Sendable
    @inlinable
    public func createVariantStore(_ input: CreateVariantStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateVariantStoreResponse {
        try await self.client.execute(
            operation: "CreateVariantStore", 
            path: "/variantStore", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Creates a variant store.
    ///
    /// Parameters:
    ///   - description: A description for the store.
    ///   - name: A name for the store.
    ///   - reference: The genome reference for the store's variants.
    ///   - sseConfig: Server-side encryption (SSE) settings for the store.
    ///   - tags: Tags for the store.
    ///   - logger: Logger use during operation
    @inlinable
    public func createVariantStore(
        description: String? = nil,
        name: String? = nil,
        reference: ReferenceItem,
        sseConfig: SseConfig? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateVariantStoreResponse {
        let input = CreateVariantStoreRequest(
            description: description, 
            name: name, 
            reference: reference, 
            sseConfig: sseConfig, 
            tags: tags
        )
        return try await self.createVariantStore(input, logger: logger)
    }

    /// Creates a private workflow. Before you create a private workflow, you must create and configure these required resources:    Workflow definition files: Define your workflow in one or more workflow definition files, written in WDL, Nextflow, or CWL. The workflow definition specifies the inputs and outputs for runs that use the workflow. It also includes specifications for the runs and run tasks for your workflow, including compute and memory requirements. The workflow definition file must be in .zip format.   (Optional) Parameter template: You can create a parameter template file that defines the run parameters, or Amazon Web Services HealthOmics can generate the parameter template for you.    ECR container images: Create container images for the workflow in a private ECR repository, or synchronize images from a supported upstream registry with your Amazon ECR private repository.   (Optional) Sentieon licenses: Request a Sentieon license if using the Sentieon software in a private workflow.   For more information, see Creating or updating a private workflow in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func createWorkflow(_ input: CreateWorkflowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWorkflowResponse {
        try await self.client.execute(
            operation: "CreateWorkflow", 
            path: "/workflow", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Creates a private workflow. Before you create a private workflow, you must create and configure these required resources:    Workflow definition files: Define your workflow in one or more workflow definition files, written in WDL, Nextflow, or CWL. The workflow definition specifies the inputs and outputs for runs that use the workflow. It also includes specifications for the runs and run tasks for your workflow, including compute and memory requirements. The workflow definition file must be in .zip format.   (Optional) Parameter template: You can create a parameter template file that defines the run parameters, or Amazon Web Services HealthOmics can generate the parameter template for you.    ECR container images: Create container images for the workflow in a private ECR repository, or synchronize images from a supported upstream registry with your Amazon ECR private repository.   (Optional) Sentieon licenses: Request a Sentieon license if using the Sentieon software in a private workflow.   For more information, see Creating or updating a private workflow in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - accelerators: The computational accelerator specified to run the workflow.
    ///   - containerRegistryMap: (Optional) Use a container registry map to specify mappings between the ECR private repository and one or more upstream registries. For more information, see Container images in the Amazon Web Services HealthOmics User Guide.
    ///   - containerRegistryMapUri: (Optional) URI of the S3 location for the registry mapping file.
    ///   - definitionRepository: The repository information for the workflow definition. This allows you to source your workflow definition directly from a code repository.
    ///   - definitionUri: The S3 URI of a definition for the workflow. The S3 bucket must be in the same region as the workflow.
    ///   - definitionZip: A ZIP archive containing the main workflow definition file and dependencies that it imports for the workflow. You can use a file with a ://fileb prefix instead of the Base64 string. For more information, see Workflow definition requirements in the Amazon Web Services HealthOmics User Guide.
    ///   - description: A description for the workflow.
    ///   - engine: The workflow engine for the workflow. This is only required if you have workflow definition files from more than one engine in your zip file. Otherwise, the service can detect the engine automatically from your workflow definition.
    ///   - main: The path of the main definition file for the workflow. This parameter is not required if the ZIP archive contains only one workflow definition file, or if the main definition file is named “main”. An example path is: workflow-definition/main-file.wdl.
    ///   - name: Name (optional but highly recommended) for the workflow to locate relevant information in the CloudWatch logs and Amazon Web Services HealthOmics console.
    ///   - parameterTemplate: A parameter template for the workflow. If this field is blank, Amazon Web Services HealthOmics will automatically parse the parameter template values from your workflow definition file. To override these service generated default values, provide a parameter template. To view an example of a parameter template, see Parameter template files in the Amazon Web Services HealthOmics User Guide.
    ///   - parameterTemplatePath: The path to the workflow parameter template JSON file within the repository. This file defines the input parameters for runs that use this workflow. If not specified, the workflow will be created without a parameter template.
    ///   - readmeMarkdown: The markdown content for the workflow's README file. This provides documentation and usage information for users of the workflow.
    ///   - readmePath: The path to the workflow README markdown file within the repository. This file provides documentation and usage information for the workflow. If not specified, the README.md file from the root directory of the repository will be used.
    ///   - readmeUri: The S3 URI of the README file for the workflow. This file provides documentation and usage information for the workflow. Requirements include:   The S3 URI must begin with s3://USER-OWNED-BUCKET/    The requester must have access to the S3 bucket and object.   The max README content length is 500 KiB.
    ///   - requestId: An idempotency token to ensure that duplicate workflows are not created when Amazon Web Services HealthOmics submits retry requests.
    ///   - storageCapacity: The default static storage capacity (in gibibytes) for runs that use this workflow or workflow version. The storageCapacity can be overwritten at run time. The storage capacity is not required for runs with a DYNAMIC storage type.
    ///   - storageType: The default storage type for runs that use this workflow. The storageType can be overridden at run time. DYNAMIC storage dynamically scales the storage up or down, based on file system utilization. STATIC storage allocates a fixed amount of storage. For more information about dynamic and static storage types, see Run storage types in the Amazon Web Services HealthOmics User Guide.
    ///   - tags: Tags for the workflow. You can define up to 50 tags for the workflow. For more information, see Adding a tag in the Amazon Web Services HealthOmics User Guide.
    ///   - workflowBucketOwnerId: The Amazon Web Services account ID of the expected owner of the S3 bucket that contains the workflow definition. If not specified, the service skips the validation.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWorkflow(
        accelerators: Accelerators? = nil,
        containerRegistryMap: ContainerRegistryMap? = nil,
        containerRegistryMapUri: String? = nil,
        definitionRepository: DefinitionRepository? = nil,
        definitionUri: String? = nil,
        definitionZip: AWSBase64Data? = nil,
        description: String? = nil,
        engine: WorkflowEngine? = nil,
        main: String? = nil,
        name: String? = nil,
        parameterTemplate: [String: WorkflowParameter]? = nil,
        parameterTemplatePath: String? = nil,
        readmeMarkdown: String? = nil,
        readmePath: String? = nil,
        readmeUri: String? = nil,
        requestId: String = CreateWorkflowRequest.idempotencyToken(),
        storageCapacity: Int? = nil,
        storageType: StorageType? = nil,
        tags: [String: String]? = nil,
        workflowBucketOwnerId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWorkflowResponse {
        let input = CreateWorkflowRequest(
            accelerators: accelerators, 
            containerRegistryMap: containerRegistryMap, 
            containerRegistryMapUri: containerRegistryMapUri, 
            definitionRepository: definitionRepository, 
            definitionUri: definitionUri, 
            definitionZip: definitionZip, 
            description: description, 
            engine: engine, 
            main: main, 
            name: name, 
            parameterTemplate: parameterTemplate, 
            parameterTemplatePath: parameterTemplatePath, 
            readmeMarkdown: readmeMarkdown, 
            readmePath: readmePath, 
            readmeUri: readmeUri, 
            requestId: requestId, 
            storageCapacity: storageCapacity, 
            storageType: storageType, 
            tags: tags, 
            workflowBucketOwnerId: workflowBucketOwnerId
        )
        return try await self.createWorkflow(input, logger: logger)
    }

    /// Creates a new workflow version for the workflow that you specify with the workflowId parameter. When you create a new version of a workflow, you need to specify the configuration for the new version. It doesn't inherit any configuration values from the workflow. Provide a version name that is unique for this workflow. You cannot change the name after HealthOmics creates the version.  Don't include any personally identifiable information (PII) in the version name. Version names appear in the workflow version ARN.  For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func createWorkflowVersion(_ input: CreateWorkflowVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWorkflowVersionResponse {
        try await self.client.execute(
            operation: "CreateWorkflowVersion", 
            path: "/workflow/{workflowId}/version", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Creates a new workflow version for the workflow that you specify with the workflowId parameter. When you create a new version of a workflow, you need to specify the configuration for the new version. It doesn't inherit any configuration values from the workflow. Provide a version name that is unique for this workflow. You cannot change the name after HealthOmics creates the version.  Don't include any personally identifiable information (PII) in the version name. Version names appear in the workflow version ARN.  For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - accelerators: The computational accelerator for this workflow version.
    ///   - containerRegistryMap: (Optional) Use a container registry map to specify mappings between the ECR private repository and one or more upstream registries. For more information, see Container images in the Amazon Web Services HealthOmics User Guide.
    ///   - containerRegistryMapUri: (Optional) URI of the S3 location for the registry mapping file.
    ///   - definitionRepository: The repository information for the workflow version definition. This allows you to source your workflow version definition directly from a code repository.
    ///   - definitionUri: The S3 URI of a definition for this workflow version. The S3 bucket must be in the same region as this workflow version.
    ///   - definitionZip: A ZIP archive containing the main workflow definition file and dependencies that it imports for this workflow version. You can use a file with a ://fileb prefix instead of the Base64 string. For more information, see Workflow definition requirements in the Amazon Web Services HealthOmics User Guide.
    ///   - description: A description for this workflow version.
    ///   - engine: The workflow engine for this workflow version. This is only required if you have workflow definition files from more than one engine in your zip file. Otherwise, the service can detect the engine automatically from your workflow definition.
    ///   - main: The path of the main definition file for this workflow version. This parameter is not required if the ZIP archive contains only one workflow definition file, or if the main definition file is named “main”. An example path is: workflow-definition/main-file.wdl.
    ///   - parameterTemplate: A parameter template for this workflow version. If this field is blank, Amazon Web Services HealthOmics will automatically parse the parameter template values from your workflow definition file. To override these service generated default values, provide a parameter template. To view an example of a parameter template, see Parameter template files in the Amazon Web Services HealthOmics User Guide.
    ///   - parameterTemplatePath: The path to the workflow version parameter template JSON file within the repository. This file defines the input parameters for runs that use this workflow version. If not specified, the workflow version will be created without a parameter template.
    ///   - readmeMarkdown: The markdown content for the workflow version's README file. This provides documentation and usage information for users of this specific workflow version.
    ///   - readmePath: The path to the workflow version README markdown file within the repository. This file provides documentation and usage information for the workflow. If not specified, the README.md file from the root directory of the repository will be used.
    ///   - readmeUri: The S3 URI of the README file for the workflow version. This file provides documentation and usage information for the workflow version. Requirements include:   The S3 URI must begin with s3://USER-OWNED-BUCKET/    The requester must have access to the S3 bucket and object.   The max README content length is 500 KiB.
    ///   - requestId: An idempotency token to ensure that duplicate workflows are not created when Amazon Web Services HealthOmics submits retry requests.
    ///   - storageCapacity: The default static storage capacity (in gibibytes) for runs that use this workflow version. The storageCapacity can be overwritten at run time. The storage capacity is not required for runs with a DYNAMIC storage type.
    ///   - storageType: The default storage type for runs that use this workflow version. The storageType can be overridden at run time. DYNAMIC storage dynamically scales the storage up or down, based on file system utilization. STATIC storage allocates a fixed amount of storage. For more information about dynamic and static storage types, see Run storage types in the Amazon Web Services HealthOmics User Guide.
    ///   - tags: Tags for this workflow version. You can define up to 50 tags for the workflow. For more information, see Adding a tag in the Amazon Web Services HealthOmics User Guide.
    ///   - versionName: A name for the workflow version. Provide a version name that is unique for this workflow. You cannot change the name after HealthOmics creates the version.  The version name must start with a letter or number and it can include upper-case and lower-case letters, numbers, hyphens, periods and underscores. The maximum length is 64 characters. You can use a simple naming scheme, such as version1, version2, version3. You can also match your workflow versions with your own internal versioning conventions, such as 2.7.0, 2.7.1, 2.7.2.
    ///   - workflowBucketOwnerId: Amazon Web Services Id of the owner of the S3 bucket that contains the workflow definition. You need to specify this parameter if your account is not the bucket owner.
    ///   - workflowId: The ID of the workflow where you are creating the new version. The workflowId is not the UUID.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWorkflowVersion(
        accelerators: Accelerators? = nil,
        containerRegistryMap: ContainerRegistryMap? = nil,
        containerRegistryMapUri: String? = nil,
        definitionRepository: DefinitionRepository? = nil,
        definitionUri: String? = nil,
        definitionZip: AWSBase64Data? = nil,
        description: String? = nil,
        engine: WorkflowEngine? = nil,
        main: String? = nil,
        parameterTemplate: [String: WorkflowParameter]? = nil,
        parameterTemplatePath: String? = nil,
        readmeMarkdown: String? = nil,
        readmePath: String? = nil,
        readmeUri: String? = nil,
        requestId: String = CreateWorkflowVersionRequest.idempotencyToken(),
        storageCapacity: Int? = nil,
        storageType: StorageType? = nil,
        tags: [String: String]? = nil,
        versionName: String,
        workflowBucketOwnerId: String? = nil,
        workflowId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWorkflowVersionResponse {
        let input = CreateWorkflowVersionRequest(
            accelerators: accelerators, 
            containerRegistryMap: containerRegistryMap, 
            containerRegistryMapUri: containerRegistryMapUri, 
            definitionRepository: definitionRepository, 
            definitionUri: definitionUri, 
            definitionZip: definitionZip, 
            description: description, 
            engine: engine, 
            main: main, 
            parameterTemplate: parameterTemplate, 
            parameterTemplatePath: parameterTemplatePath, 
            readmeMarkdown: readmeMarkdown, 
            readmePath: readmePath, 
            readmeUri: readmeUri, 
            requestId: requestId, 
            storageCapacity: storageCapacity, 
            storageType: storageType, 
            tags: tags, 
            versionName: versionName, 
            workflowBucketOwnerId: workflowBucketOwnerId, 
            workflowId: workflowId
        )
        return try await self.createWorkflowVersion(input, logger: logger)
    }

    /// Deletes an annotation store.
    @Sendable
    @inlinable
    public func deleteAnnotationStore(_ input: DeleteAnnotationStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAnnotationStoreResponse {
        try await self.client.execute(
            operation: "DeleteAnnotationStore", 
            path: "/annotationStore/{name}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Deletes an annotation store.
    ///
    /// Parameters:
    ///   - force: Whether to force deletion.
    ///   - name: The store's name.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAnnotationStore(
        force: Bool? = nil,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAnnotationStoreResponse {
        let input = DeleteAnnotationStoreRequest(
            force: force, 
            name: name
        )
        return try await self.deleteAnnotationStore(input, logger: logger)
    }

    ///  Deletes one or multiple versions of an annotation store.
    @Sendable
    @inlinable
    public func deleteAnnotationStoreVersions(_ input: DeleteAnnotationStoreVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAnnotationStoreVersionsResponse {
        try await self.client.execute(
            operation: "DeleteAnnotationStoreVersions", 
            path: "/annotationStore/{name}/versions/delete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    ///  Deletes one or multiple versions of an annotation store.
    ///
    /// Parameters:
    ///   - force:  Forces the deletion of an annotation store version when imports are in-progress..
    ///   - name:  The name of the annotation store from which versions are being deleted.
    ///   - versions:  The versions of an annotation store to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAnnotationStoreVersions(
        force: Bool? = nil,
        name: String,
        versions: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAnnotationStoreVersionsResponse {
        let input = DeleteAnnotationStoreVersionsRequest(
            force: force, 
            name: name, 
            versions: versions
        )
        return try await self.deleteAnnotationStoreVersions(input, logger: logger)
    }

    /// Deletes a reference genome and returns a response with no body if the operation is successful. The read set associated with the reference genome must first be deleted before deleting the reference genome. After the reference genome is deleted, you can delete the reference store using the DeleteReferenceStore API operation. For more information, see Deleting HealthOmics reference and sequence stores in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func deleteReference(_ input: DeleteReferenceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteReferenceResponse {
        try await self.client.execute(
            operation: "DeleteReference", 
            path: "/referencestore/{referenceStoreId}/reference/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Deletes a reference genome and returns a response with no body if the operation is successful. The read set associated with the reference genome must first be deleted before deleting the reference genome. After the reference genome is deleted, you can delete the reference store using the DeleteReferenceStore API operation. For more information, see Deleting HealthOmics reference and sequence stores in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - id: The reference's ID.
    ///   - referenceStoreId: The reference's store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteReference(
        id: String,
        referenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteReferenceResponse {
        let input = DeleteReferenceRequest(
            id: id, 
            referenceStoreId: referenceStoreId
        )
        return try await self.deleteReference(input, logger: logger)
    }

    /// Deletes a reference store and returns a response with no body if the operation is successful. You can only delete a reference store when it does not contain any reference genomes. To empty a reference store, use DeleteReference. For more information about your workflow status, see Deleting HealthOmics reference and sequence stores in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func deleteReferenceStore(_ input: DeleteReferenceStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteReferenceStoreResponse {
        try await self.client.execute(
            operation: "DeleteReferenceStore", 
            path: "/referencestore/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Deletes a reference store and returns a response with no body if the operation is successful. You can only delete a reference store when it does not contain any reference genomes. To empty a reference store, use DeleteReference. For more information about your workflow status, see Deleting HealthOmics reference and sequence stores in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - id: The store's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteReferenceStore(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteReferenceStoreResponse {
        let input = DeleteReferenceStoreRequest(
            id: id
        )
        return try await self.deleteReferenceStore(input, logger: logger)
    }

    /// Deletes a run and returns a response with no body if the operation is successful. You can only delete a run that has reached a COMPLETED, FAILED, or CANCELLED stage. A completed run has delivered an output, or was cancelled and resulted in no output. When you delete a run, only the metadata associated with the run is deleted. The run outputs remain in Amazon S3 and logs remain in CloudWatch. To verify that the workflow is deleted:   Use ListRuns to confirm the workflow no longer appears in the list.   Use GetRun to verify the workflow cannot be found.
    @Sendable
    @inlinable
    public func deleteRun(_ input: DeleteRunRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteRun", 
            path: "/run/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Deletes a run and returns a response with no body if the operation is successful. You can only delete a run that has reached a COMPLETED, FAILED, or CANCELLED stage. A completed run has delivered an output, or was cancelled and resulted in no output. When you delete a run, only the metadata associated with the run is deleted. The run outputs remain in Amazon S3 and logs remain in CloudWatch. To verify that the workflow is deleted:   Use ListRuns to confirm the workflow no longer appears in the list.   Use GetRun to verify the workflow cannot be found.
    ///
    /// Parameters:
    ///   - id: The run's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRun(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteRunRequest(
            id: id
        )
        return try await self.deleteRun(input, logger: logger)
    }

    /// Deletes a run cache and returns a response with no body if the operation is successful. This action removes the cache metadata stored in the service account, but does not delete the data in Amazon S3. You can access the cache data in Amazon S3, for inspection or to troubleshoot issues. You can remove old cache data using standard S3 Delete operations.  For more information, see Deleting a run cache in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func deleteRunCache(_ input: DeleteRunCacheRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteRunCache", 
            path: "/runCache/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Deletes a run cache and returns a response with no body if the operation is successful. This action removes the cache metadata stored in the service account, but does not delete the data in Amazon S3. You can access the cache data in Amazon S3, for inspection or to troubleshoot issues. You can remove old cache data using standard S3 Delete operations.  For more information, see Deleting a run cache in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - id: Run cache identifier for the cache you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRunCache(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteRunCacheRequest(
            id: id
        )
        return try await self.deleteRunCache(input, logger: logger)
    }

    /// Deletes a run group and returns a response with no body if the operation is successful. To verify that the run group is deleted:   Use ListRunGroups to confirm the workflow no longer appears in the list.   Use GetRunGroup to verify the workflow cannot be found.
    @Sendable
    @inlinable
    public func deleteRunGroup(_ input: DeleteRunGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteRunGroup", 
            path: "/runGroup/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Deletes a run group and returns a response with no body if the operation is successful. To verify that the run group is deleted:   Use ListRunGroups to confirm the workflow no longer appears in the list.   Use GetRunGroup to verify the workflow cannot be found.
    ///
    /// Parameters:
    ///   - id: The run group's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRunGroup(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteRunGroupRequest(
            id: id
        )
        return try await self.deleteRunGroup(input, logger: logger)
    }

    /// Deletes an access policy for the specified store.
    @Sendable
    @inlinable
    public func deleteS3AccessPolicy(_ input: DeleteS3AccessPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteS3AccessPolicyResponse {
        try await self.client.execute(
            operation: "DeleteS3AccessPolicy", 
            path: "/s3accesspolicy/{s3AccessPointArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Deletes an access policy for the specified store.
    ///
    /// Parameters:
    ///   - s3AccessPointArn: The S3 access point ARN that has the access policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteS3AccessPolicy(
        s3AccessPointArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteS3AccessPolicyResponse {
        let input = DeleteS3AccessPolicyRequest(
            s3AccessPointArn: s3AccessPointArn
        )
        return try await self.deleteS3AccessPolicy(input, logger: logger)
    }

    /// Deletes a sequence store and returns a response with no body if the operation is successful. You can only delete a sequence store when it does not contain any read sets. Use the BatchDeleteReadSet API operation to ensure that all read sets in the sequence store are deleted. When a sequence store is deleted, all tags associated with the store are also deleted. For more information, see Deleting HealthOmics reference and sequence stores in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func deleteSequenceStore(_ input: DeleteSequenceStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSequenceStoreResponse {
        try await self.client.execute(
            operation: "DeleteSequenceStore", 
            path: "/sequencestore/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Deletes a sequence store and returns a response with no body if the operation is successful. You can only delete a sequence store when it does not contain any read sets. Use the BatchDeleteReadSet API operation to ensure that all read sets in the sequence store are deleted. When a sequence store is deleted, all tags associated with the store are also deleted. For more information, see Deleting HealthOmics reference and sequence stores in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - id: The sequence store's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSequenceStore(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSequenceStoreResponse {
        let input = DeleteSequenceStoreRequest(
            id: id
        )
        return try await self.deleteSequenceStore(input, logger: logger)
    }

    /// Deletes a resource share. If you are the resource owner, the subscriber will no longer have access to the shared resource. If you are the subscriber, this operation deletes your access to the share.
    @Sendable
    @inlinable
    public func deleteShare(_ input: DeleteShareRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteShareResponse {
        try await self.client.execute(
            operation: "DeleteShare", 
            path: "/share/{shareId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Deletes a resource share. If you are the resource owner, the subscriber will no longer have access to the shared resource. If you are the subscriber, this operation deletes your access to the share.
    ///
    /// Parameters:
    ///   - shareId: The ID for the resource share to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteShare(
        shareId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteShareResponse {
        let input = DeleteShareRequest(
            shareId: shareId
        )
        return try await self.deleteShare(input, logger: logger)
    }

    /// Deletes a variant store.
    @Sendable
    @inlinable
    public func deleteVariantStore(_ input: DeleteVariantStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteVariantStoreResponse {
        try await self.client.execute(
            operation: "DeleteVariantStore", 
            path: "/variantStore/{name}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Deletes a variant store.
    ///
    /// Parameters:
    ///   - force: Whether to force deletion.
    ///   - name: The store's name.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteVariantStore(
        force: Bool? = nil,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteVariantStoreResponse {
        let input = DeleteVariantStoreRequest(
            force: force, 
            name: name
        )
        return try await self.deleteVariantStore(input, logger: logger)
    }

    /// Deletes a workflow by specifying its ID. This operation returns a response with no body if the deletion is successful. To verify that the workflow is deleted:   Use ListWorkflows to confirm the workflow no longer appears in the list.   Use GetWorkflow to verify the workflow cannot be found.
    @Sendable
    @inlinable
    public func deleteWorkflow(_ input: DeleteWorkflowRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteWorkflow", 
            path: "/workflow/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Deletes a workflow by specifying its ID. This operation returns a response with no body if the deletion is successful. To verify that the workflow is deleted:   Use ListWorkflows to confirm the workflow no longer appears in the list.   Use GetWorkflow to verify the workflow cannot be found.
    ///
    /// Parameters:
    ///   - id: The workflow's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWorkflow(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteWorkflowRequest(
            id: id
        )
        return try await self.deleteWorkflow(input, logger: logger)
    }

    /// Deletes a workflow version. Deleting a workflow version doesn't affect any ongoing runs that are using the workflow version. For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func deleteWorkflowVersion(_ input: DeleteWorkflowVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteWorkflowVersion", 
            path: "/workflow/{workflowId}/version/{versionName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Deletes a workflow version. Deleting a workflow version doesn't affect any ongoing runs that are using the workflow version. For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - versionName: The workflow version name.
    ///   - workflowId: The workflow's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWorkflowVersion(
        versionName: String,
        workflowId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteWorkflowVersionRequest(
            versionName: versionName, 
            workflowId: workflowId
        )
        return try await self.deleteWorkflowVersion(input, logger: logger)
    }

    /// Gets information about an annotation import job.
    @Sendable
    @inlinable
    public func getAnnotationImportJob(_ input: GetAnnotationImportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAnnotationImportResponse {
        try await self.client.execute(
            operation: "GetAnnotationImportJob", 
            path: "/import/annotation/{jobId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Gets information about an annotation import job.
    ///
    /// Parameters:
    ///   - jobId: The job's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAnnotationImportJob(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAnnotationImportResponse {
        let input = GetAnnotationImportRequest(
            jobId: jobId
        )
        return try await self.getAnnotationImportJob(input, logger: logger)
    }

    /// Gets information about an annotation store.
    @Sendable
    @inlinable
    public func getAnnotationStore(_ input: GetAnnotationStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAnnotationStoreResponse {
        try await self.client.execute(
            operation: "GetAnnotationStore", 
            path: "/annotationStore/{name}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Gets information about an annotation store.
    ///
    /// Parameters:
    ///   - name: The store's name.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAnnotationStore(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAnnotationStoreResponse {
        let input = GetAnnotationStoreRequest(
            name: name
        )
        return try await self.getAnnotationStore(input, logger: logger)
    }

    ///  Retrieves the metadata for an annotation store version.
    @Sendable
    @inlinable
    public func getAnnotationStoreVersion(_ input: GetAnnotationStoreVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAnnotationStoreVersionResponse {
        try await self.client.execute(
            operation: "GetAnnotationStoreVersion", 
            path: "/annotationStore/{name}/version/{versionName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    ///  Retrieves the metadata for an annotation store version.
    ///
    /// Parameters:
    ///   - name:  The name given to an annotation store version to distinguish it from others.
    ///   - versionName:  The name given to an annotation store version to distinguish it from others.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAnnotationStoreVersion(
        name: String,
        versionName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAnnotationStoreVersionResponse {
        let input = GetAnnotationStoreVersionRequest(
            name: name, 
            versionName: versionName
        )
        return try await self.getAnnotationStoreVersion(input, logger: logger)
    }

    /// Retrieves detailed information from parts of a read set and returns the read set in the same format that it was uploaded. You must have read sets uploaded to your sequence store in order to run this operation.
    @Sendable
    @inlinable
    public func getReadSet(_ input: GetReadSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReadSetResponse {
        try await self.client.execute(
            operation: "GetReadSet", 
            path: "/sequencestore/{sequenceStoreId}/readset/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "storage-", 
            logger: logger
        )
    }
    /// Retrieves detailed information from parts of a read set and returns the read set in the same format that it was uploaded. You must have read sets uploaded to your sequence store in order to run this operation.
    ///
    /// Parameters:
    ///   - file: The file to retrieve.
    ///   - id: The read set's ID.
    ///   - partNumber: The part number to retrieve.
    ///   - sequenceStoreId: The read set's sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReadSet(
        file: ReadSetFile? = nil,
        id: String,
        partNumber: Int,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReadSetResponse {
        let input = GetReadSetRequest(
            file: file, 
            id: id, 
            partNumber: partNumber, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.getReadSet(input, logger: logger)
    }

    /// Returns detailed information about the status of a read set activation job in JSON format.
    @Sendable
    @inlinable
    public func getReadSetActivationJob(_ input: GetReadSetActivationJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReadSetActivationJobResponse {
        try await self.client.execute(
            operation: "GetReadSetActivationJob", 
            path: "/sequencestore/{sequenceStoreId}/activationjob/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Returns detailed information about the status of a read set activation job in JSON format.
    ///
    /// Parameters:
    ///   - id: The job's ID.
    ///   - sequenceStoreId: The job's sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReadSetActivationJob(
        id: String,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReadSetActivationJobResponse {
        let input = GetReadSetActivationJobRequest(
            id: id, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.getReadSetActivationJob(input, logger: logger)
    }

    /// Retrieves status information about a read set export job and returns the data in JSON format. Use this operation to actively monitor the progress of an export job.
    @Sendable
    @inlinable
    public func getReadSetExportJob(_ input: GetReadSetExportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReadSetExportJobResponse {
        try await self.client.execute(
            operation: "GetReadSetExportJob", 
            path: "/sequencestore/{sequenceStoreId}/exportjob/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves status information about a read set export job and returns the data in JSON format. Use this operation to actively monitor the progress of an export job.
    ///
    /// Parameters:
    ///   - id: The job's ID.
    ///   - sequenceStoreId: The job's sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReadSetExportJob(
        id: String,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReadSetExportJobResponse {
        let input = GetReadSetExportJobRequest(
            id: id, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.getReadSetExportJob(input, logger: logger)
    }

    /// Gets detailed and status information about a read set import job and returns the data in JSON format.
    @Sendable
    @inlinable
    public func getReadSetImportJob(_ input: GetReadSetImportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReadSetImportJobResponse {
        try await self.client.execute(
            operation: "GetReadSetImportJob", 
            path: "/sequencestore/{sequenceStoreId}/importjob/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Gets detailed and status information about a read set import job and returns the data in JSON format.
    ///
    /// Parameters:
    ///   - id: The job's ID.
    ///   - sequenceStoreId: The job's sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReadSetImportJob(
        id: String,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReadSetImportJobResponse {
        let input = GetReadSetImportJobRequest(
            id: id, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.getReadSetImportJob(input, logger: logger)
    }

    /// Retrieves the metadata for a read set from a sequence store in JSON format. This operation does not return tags. To retrieve the list of tags for a read set, use the ListTagsForResource API operation.
    @Sendable
    @inlinable
    public func getReadSetMetadata(_ input: GetReadSetMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReadSetMetadataResponse {
        try await self.client.execute(
            operation: "GetReadSetMetadata", 
            path: "/sequencestore/{sequenceStoreId}/readset/{id}/metadata", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves the metadata for a read set from a sequence store in JSON format. This operation does not return tags. To retrieve the list of tags for a read set, use the ListTagsForResource API operation.
    ///
    /// Parameters:
    ///   - id: The read set's ID.
    ///   - sequenceStoreId: The read set's sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReadSetMetadata(
        id: String,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReadSetMetadataResponse {
        let input = GetReadSetMetadataRequest(
            id: id, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.getReadSetMetadata(input, logger: logger)
    }

    /// Downloads parts of data from a reference genome and returns the reference file in the same format that it was uploaded. For more information, see Creating a HealthOmics reference store in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func getReference(_ input: GetReferenceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReferenceResponse {
        try await self.client.execute(
            operation: "GetReference", 
            path: "/referencestore/{referenceStoreId}/reference/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "storage-", 
            logger: logger
        )
    }
    /// Downloads parts of data from a reference genome and returns the reference file in the same format that it was uploaded. For more information, see Creating a HealthOmics reference store in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - file: The file to retrieve.
    ///   - id: The reference's ID.
    ///   - partNumber: The part number to retrieve.
    ///   - range: The range to retrieve.
    ///   - referenceStoreId: The reference's store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReference(
        file: ReferenceFile? = nil,
        id: String,
        partNumber: Int,
        range: String? = nil,
        referenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReferenceResponse {
        let input = GetReferenceRequest(
            file: file, 
            id: id, 
            partNumber: partNumber, 
            range: range, 
            referenceStoreId: referenceStoreId
        )
        return try await self.getReference(input, logger: logger)
    }

    /// Monitors the status of a reference import job. This operation can be called after calling the StartReferenceImportJob operation.
    @Sendable
    @inlinable
    public func getReferenceImportJob(_ input: GetReferenceImportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReferenceImportJobResponse {
        try await self.client.execute(
            operation: "GetReferenceImportJob", 
            path: "/referencestore/{referenceStoreId}/importjob/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Monitors the status of a reference import job. This operation can be called after calling the StartReferenceImportJob operation.
    ///
    /// Parameters:
    ///   - id: The job's ID.
    ///   - referenceStoreId: The job's reference store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReferenceImportJob(
        id: String,
        referenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReferenceImportJobResponse {
        let input = GetReferenceImportJobRequest(
            id: id, 
            referenceStoreId: referenceStoreId
        )
        return try await self.getReferenceImportJob(input, logger: logger)
    }

    /// Retrieves metadata for a reference genome. This operation returns the number of parts, part size, and MD5 of an entire file. This operation does not return tags. To retrieve the list of tags for a read set, use the ListTagsForResource API operation.
    @Sendable
    @inlinable
    public func getReferenceMetadata(_ input: GetReferenceMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReferenceMetadataResponse {
        try await self.client.execute(
            operation: "GetReferenceMetadata", 
            path: "/referencestore/{referenceStoreId}/reference/{id}/metadata", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves metadata for a reference genome. This operation returns the number of parts, part size, and MD5 of an entire file. This operation does not return tags. To retrieve the list of tags for a read set, use the ListTagsForResource API operation.
    ///
    /// Parameters:
    ///   - id: The reference's ID.
    ///   - referenceStoreId: The reference's reference store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReferenceMetadata(
        id: String,
        referenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReferenceMetadataResponse {
        let input = GetReferenceMetadataRequest(
            id: id, 
            referenceStoreId: referenceStoreId
        )
        return try await self.getReferenceMetadata(input, logger: logger)
    }

    /// Gets information about a reference store.
    @Sendable
    @inlinable
    public func getReferenceStore(_ input: GetReferenceStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReferenceStoreResponse {
        try await self.client.execute(
            operation: "GetReferenceStore", 
            path: "/referencestore/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Gets information about a reference store.
    ///
    /// Parameters:
    ///   - id: The store's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReferenceStore(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReferenceStoreResponse {
        let input = GetReferenceStoreRequest(
            id: id
        )
        return try await self.getReferenceStore(input, logger: logger)
    }

    /// Gets detailed information about a specific run using its ID. Amazon Web Services HealthOmics stores a configurable number of runs, as determined by service limits, that are available to the console and API. If GetRun does not return the requested run, you can find all run logs in the CloudWatch logs. For more information about viewing the run logs, see CloudWatch logs in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func getRun(_ input: GetRunRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRunResponse {
        try await self.client.execute(
            operation: "GetRun", 
            path: "/run/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Gets detailed information about a specific run using its ID. Amazon Web Services HealthOmics stores a configurable number of runs, as determined by service limits, that are available to the console and API. If GetRun does not return the requested run, you can find all run logs in the CloudWatch logs. For more information about viewing the run logs, see CloudWatch logs in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - export: The run's export format.
    ///   - id: The run's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRun(
        export: [RunExport]? = nil,
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRunResponse {
        let input = GetRunRequest(
            export: export, 
            id: id
        )
        return try await self.getRun(input, logger: logger)
    }

    /// Retrieves detailed information about the specified run cache using its ID. For more information, see Call caching for Amazon Web Services HealthOmics runs in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func getRunCache(_ input: GetRunCacheRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRunCacheResponse {
        try await self.client.execute(
            operation: "GetRunCache", 
            path: "/runCache/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Retrieves detailed information about the specified run cache using its ID. For more information, see Call caching for Amazon Web Services HealthOmics runs in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - id: The identifier of the run cache to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRunCache(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRunCacheResponse {
        let input = GetRunCacheRequest(
            id: id
        )
        return try await self.getRunCache(input, logger: logger)
    }

    /// Gets information about a run group and returns its metadata.
    @Sendable
    @inlinable
    public func getRunGroup(_ input: GetRunGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRunGroupResponse {
        try await self.client.execute(
            operation: "GetRunGroup", 
            path: "/runGroup/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Gets information about a run group and returns its metadata.
    ///
    /// Parameters:
    ///   - id: The group's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRunGroup(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRunGroupResponse {
        let input = GetRunGroupRequest(
            id: id
        )
        return try await self.getRunGroup(input, logger: logger)
    }

    /// Gets detailed information about a run task using its ID.
    @Sendable
    @inlinable
    public func getRunTask(_ input: GetRunTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRunTaskResponse {
        try await self.client.execute(
            operation: "GetRunTask", 
            path: "/run/{id}/task/{taskId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Gets detailed information about a run task using its ID.
    ///
    /// Parameters:
    ///   - id: The workflow run ID.
    ///   - taskId: The task's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRunTask(
        id: String,
        taskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRunTaskResponse {
        let input = GetRunTaskRequest(
            id: id, 
            taskId: taskId
        )
        return try await self.getRunTask(input, logger: logger)
    }

    /// Retrieves details about an access policy on a given store.
    @Sendable
    @inlinable
    public func getS3AccessPolicy(_ input: GetS3AccessPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetS3AccessPolicyResponse {
        try await self.client.execute(
            operation: "GetS3AccessPolicy", 
            path: "/s3accesspolicy/{s3AccessPointArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves details about an access policy on a given store.
    ///
    /// Parameters:
    ///   - s3AccessPointArn: The S3 access point ARN that has the access policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func getS3AccessPolicy(
        s3AccessPointArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetS3AccessPolicyResponse {
        let input = GetS3AccessPolicyRequest(
            s3AccessPointArn: s3AccessPointArn
        )
        return try await self.getS3AccessPolicy(input, logger: logger)
    }

    /// Retrieves metadata for a sequence store using its ID and returns it in JSON format.
    @Sendable
    @inlinable
    public func getSequenceStore(_ input: GetSequenceStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSequenceStoreResponse {
        try await self.client.execute(
            operation: "GetSequenceStore", 
            path: "/sequencestore/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves metadata for a sequence store using its ID and returns it in JSON format.
    ///
    /// Parameters:
    ///   - id: The store's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSequenceStore(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSequenceStoreResponse {
        let input = GetSequenceStoreRequest(
            id: id
        )
        return try await self.getSequenceStore(input, logger: logger)
    }

    /// Retrieves the metadata for the specified resource share.
    @Sendable
    @inlinable
    public func getShare(_ input: GetShareRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetShareResponse {
        try await self.client.execute(
            operation: "GetShare", 
            path: "/share/{shareId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Retrieves the metadata for the specified resource share.
    ///
    /// Parameters:
    ///   - shareId: The ID of the share.
    ///   - logger: Logger use during operation
    @inlinable
    public func getShare(
        shareId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetShareResponse {
        let input = GetShareRequest(
            shareId: shareId
        )
        return try await self.getShare(input, logger: logger)
    }

    /// Gets information about a variant import job.
    @Sendable
    @inlinable
    public func getVariantImportJob(_ input: GetVariantImportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetVariantImportResponse {
        try await self.client.execute(
            operation: "GetVariantImportJob", 
            path: "/import/variant/{jobId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Gets information about a variant import job.
    ///
    /// Parameters:
    ///   - jobId: The job's ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getVariantImportJob(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetVariantImportResponse {
        let input = GetVariantImportRequest(
            jobId: jobId
        )
        return try await self.getVariantImportJob(input, logger: logger)
    }

    /// Gets information about a variant store.
    @Sendable
    @inlinable
    public func getVariantStore(_ input: GetVariantStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetVariantStoreResponse {
        try await self.client.execute(
            operation: "GetVariantStore", 
            path: "/variantStore/{name}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Gets information about a variant store.
    ///
    /// Parameters:
    ///   - name: The store's name.
    ///   - logger: Logger use during operation
    @inlinable
    public func getVariantStore(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetVariantStoreResponse {
        let input = GetVariantStoreRequest(
            name: name
        )
        return try await self.getVariantStore(input, logger: logger)
    }

    /// Gets all information about a workflow using its ID. If a workflow is shared with you, you cannot export the workflow. For more information about your workflow status, see Verify the workflow status in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func getWorkflow(_ input: GetWorkflowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWorkflowResponse {
        try await self.client.execute(
            operation: "GetWorkflow", 
            path: "/workflow/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Gets all information about a workflow using its ID. If a workflow is shared with you, you cannot export the workflow. For more information about your workflow status, see Verify the workflow status in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - export: The export format for the workflow.
    ///   - id: The workflow's ID.
    ///   - type: The workflow's type.
    ///   - workflowOwnerId: The ID of the workflow owner.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWorkflow(
        export: [WorkflowExport]? = nil,
        id: String,
        type: WorkflowType? = nil,
        workflowOwnerId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWorkflowResponse {
        let input = GetWorkflowRequest(
            export: export, 
            id: id, 
            type: type, 
            workflowOwnerId: workflowOwnerId
        )
        return try await self.getWorkflow(input, logger: logger)
    }

    /// Gets information about a workflow version. For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func getWorkflowVersion(_ input: GetWorkflowVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWorkflowVersionResponse {
        try await self.client.execute(
            operation: "GetWorkflowVersion", 
            path: "/workflow/{workflowId}/version/{versionName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Gets information about a workflow version. For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - export: The export format for the workflow.
    ///   - type: The workflow's type.
    ///   - versionName: The workflow version name.
    ///   - workflowId: The workflow's ID. The workflowId is not the UUID.
    ///   - workflowOwnerId: The 12-digit account ID of the workflow owner. The workflow owner ID can be retrieved using the GetShare API operation. If you are the workflow owner, you do not need to include this ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWorkflowVersion(
        export: [WorkflowExport]? = nil,
        type: WorkflowType? = nil,
        versionName: String,
        workflowId: String,
        workflowOwnerId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWorkflowVersionResponse {
        let input = GetWorkflowVersionRequest(
            export: export, 
            type: type, 
            versionName: versionName, 
            workflowId: workflowId, 
            workflowOwnerId: workflowOwnerId
        )
        return try await self.getWorkflowVersion(input, logger: logger)
    }

    /// Retrieves a list of annotation import jobs.
    @Sendable
    @inlinable
    public func listAnnotationImportJobs(_ input: ListAnnotationImportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAnnotationImportJobsResponse {
        try await self.client.execute(
            operation: "ListAnnotationImportJobs", 
            path: "/import/annotations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Retrieves a list of annotation import jobs.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - ids: IDs of annotation import jobs to retrieve.
    ///   - maxResults: The maximum number of jobs to return in one page of results.
    ///   - nextToken: Specifies the pagination token from a previous request to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAnnotationImportJobs(
        filter: ListAnnotationImportJobsFilter? = nil,
        ids: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAnnotationImportJobsResponse {
        let input = ListAnnotationImportJobsRequest(
            filter: filter, 
            ids: ids, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAnnotationImportJobs(input, logger: logger)
    }

    ///  Lists the versions of an annotation store.
    @Sendable
    @inlinable
    public func listAnnotationStoreVersions(_ input: ListAnnotationStoreVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAnnotationStoreVersionsResponse {
        try await self.client.execute(
            operation: "ListAnnotationStoreVersions", 
            path: "/annotationStore/{name}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    ///  Lists the versions of an annotation store.
    ///
    /// Parameters:
    ///   - filter:  A filter to apply to the list of annotation store versions.
    ///   - maxResults:  The maximum number of annotation store versions to return in one page of results.
    ///   - name:  The name of an annotation store.
    ///   - nextToken:  Specifies the pagination token from a previous request to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAnnotationStoreVersions(
        filter: ListAnnotationStoreVersionsFilter? = nil,
        maxResults: Int? = nil,
        name: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAnnotationStoreVersionsResponse {
        let input = ListAnnotationStoreVersionsRequest(
            filter: filter, 
            maxResults: maxResults, 
            name: name, 
            nextToken: nextToken
        )
        return try await self.listAnnotationStoreVersions(input, logger: logger)
    }

    /// Retrieves a list of annotation stores.
    @Sendable
    @inlinable
    public func listAnnotationStores(_ input: ListAnnotationStoresRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAnnotationStoresResponse {
        try await self.client.execute(
            operation: "ListAnnotationStores", 
            path: "/annotationStores", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Retrieves a list of annotation stores.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - ids: IDs of stores to list.
    ///   - maxResults: The maximum number of stores to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAnnotationStores(
        filter: ListAnnotationStoresFilter? = nil,
        ids: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAnnotationStoresResponse {
        let input = ListAnnotationStoresRequest(
            filter: filter, 
            ids: ids, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAnnotationStores(input, logger: logger)
    }

    /// Lists in-progress multipart read set uploads for a sequence store and returns it in a JSON formatted output. Multipart read set uploads are initiated by the CreateMultipartReadSetUploads API operation. This operation returns a response with no body when the upload is complete.
    @Sendable
    @inlinable
    public func listMultipartReadSetUploads(_ input: ListMultipartReadSetUploadsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMultipartReadSetUploadsResponse {
        try await self.client.execute(
            operation: "ListMultipartReadSetUploads", 
            path: "/sequencestore/{sequenceStoreId}/uploads", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Lists in-progress multipart read set uploads for a sequence store and returns it in a JSON formatted output. Multipart read set uploads are initiated by the CreateMultipartReadSetUploads API operation. This operation returns a response with no body when the upload is complete.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of multipart uploads returned in a page.
    ///   - nextToken: Next token returned in the response of a previous ListMultipartReadSetUploads call. Used to get the next page of results.
    ///   - sequenceStoreId: The Sequence Store ID used for the multipart uploads.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMultipartReadSetUploads(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMultipartReadSetUploadsResponse {
        let input = ListMultipartReadSetUploadsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.listMultipartReadSetUploads(input, logger: logger)
    }

    /// Retrieves a list of read set activation jobs and returns the metadata in a JSON formatted output. To extract metadata from a read set activation job, use the GetReadSetActivationJob API operation.
    @Sendable
    @inlinable
    public func listReadSetActivationJobs(_ input: ListReadSetActivationJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReadSetActivationJobsResponse {
        try await self.client.execute(
            operation: "ListReadSetActivationJobs", 
            path: "/sequencestore/{sequenceStoreId}/activationjobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves a list of read set activation jobs and returns the metadata in a JSON formatted output. To extract metadata from a read set activation job, use the GetReadSetActivationJob API operation.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of read set activation jobs to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - sequenceStoreId: The read set's sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReadSetActivationJobs(
        filter: ActivateReadSetFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReadSetActivationJobsResponse {
        let input = ListReadSetActivationJobsRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.listReadSetActivationJobs(input, logger: logger)
    }

    /// Retrieves a list of read set export jobs in a JSON formatted response. This API operation is used to check the status of a read set export job initiated by the StartReadSetExportJob API operation.
    @Sendable
    @inlinable
    public func listReadSetExportJobs(_ input: ListReadSetExportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReadSetExportJobsResponse {
        try await self.client.execute(
            operation: "ListReadSetExportJobs", 
            path: "/sequencestore/{sequenceStoreId}/exportjobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves a list of read set export jobs in a JSON formatted response. This API operation is used to check the status of a read set export job initiated by the StartReadSetExportJob API operation.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of jobs to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - sequenceStoreId: The jobs' sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReadSetExportJobs(
        filter: ExportReadSetFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReadSetExportJobsResponse {
        let input = ListReadSetExportJobsRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.listReadSetExportJobs(input, logger: logger)
    }

    /// Retrieves a list of read set import jobs and returns the data in JSON format.
    @Sendable
    @inlinable
    public func listReadSetImportJobs(_ input: ListReadSetImportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReadSetImportJobsResponse {
        try await self.client.execute(
            operation: "ListReadSetImportJobs", 
            path: "/sequencestore/{sequenceStoreId}/importjobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves a list of read set import jobs and returns the data in JSON format.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of jobs to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - sequenceStoreId: The jobs' sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReadSetImportJobs(
        filter: ImportReadSetFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReadSetImportJobsResponse {
        let input = ListReadSetImportJobsRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.listReadSetImportJobs(input, logger: logger)
    }

    /// Lists all parts in a multipart read set upload for a sequence store and returns the metadata in a JSON formatted output.
    @Sendable
    @inlinable
    public func listReadSetUploadParts(_ input: ListReadSetUploadPartsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReadSetUploadPartsResponse {
        try await self.client.execute(
            operation: "ListReadSetUploadParts", 
            path: "/sequencestore/{sequenceStoreId}/upload/{uploadId}/parts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Lists all parts in a multipart read set upload for a sequence store and returns the metadata in a JSON formatted output.
    ///
    /// Parameters:
    ///   - filter: Attributes used to filter for a specific subset of read set part uploads.
    ///   - maxResults: The maximum number of read set upload parts returned in a page.
    ///   - nextToken: Next token returned in the response of a previous ListReadSetUploadPartsRequest call. Used to get the next page of results.
    ///   - partSource: The source file for the upload part.
    ///   - sequenceStoreId: The Sequence Store ID used for the multipart uploads.
    ///   - uploadId: The ID for the initiated multipart upload.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReadSetUploadParts(
        filter: ReadSetUploadPartListFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        partSource: ReadSetPartSource,
        sequenceStoreId: String,
        uploadId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReadSetUploadPartsResponse {
        let input = ListReadSetUploadPartsRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            partSource: partSource, 
            sequenceStoreId: sequenceStoreId, 
            uploadId: uploadId
        )
        return try await self.listReadSetUploadParts(input, logger: logger)
    }

    /// Retrieves a list of read sets from a sequence store ID and returns the metadata in JSON format.
    @Sendable
    @inlinable
    public func listReadSets(_ input: ListReadSetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReadSetsResponse {
        try await self.client.execute(
            operation: "ListReadSets", 
            path: "/sequencestore/{sequenceStoreId}/readsets", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves a list of read sets from a sequence store ID and returns the metadata in JSON format.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of read sets to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - sequenceStoreId: The jobs' sequence store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReadSets(
        filter: ReadSetFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReadSetsResponse {
        let input = ListReadSetsRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sequenceStoreId: sequenceStoreId
        )
        return try await self.listReadSets(input, logger: logger)
    }

    /// Retrieves the metadata of one or more reference import jobs for a reference store.
    @Sendable
    @inlinable
    public func listReferenceImportJobs(_ input: ListReferenceImportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReferenceImportJobsResponse {
        try await self.client.execute(
            operation: "ListReferenceImportJobs", 
            path: "/referencestore/{referenceStoreId}/importjobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves the metadata of one or more reference import jobs for a reference store.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of jobs to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - referenceStoreId: The job's reference store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReferenceImportJobs(
        filter: ImportReferenceFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        referenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReferenceImportJobsResponse {
        let input = ListReferenceImportJobsRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            referenceStoreId: referenceStoreId
        )
        return try await self.listReferenceImportJobs(input, logger: logger)
    }

    /// Retrieves a list of reference stores linked to your account and returns their metadata in JSON format. For more information, see Creating a reference store in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func listReferenceStores(_ input: ListReferenceStoresRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReferenceStoresResponse {
        try await self.client.execute(
            operation: "ListReferenceStores", 
            path: "/referencestores", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves a list of reference stores linked to your account and returns their metadata in JSON format. For more information, see Creating a reference store in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of stores to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReferenceStores(
        filter: ReferenceStoreFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReferenceStoresResponse {
        let input = ListReferenceStoresRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReferenceStores(input, logger: logger)
    }

    /// Retrieves the metadata of one or more reference genomes in a reference store. For more information, see Creating a reference store in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func listReferences(_ input: ListReferencesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReferencesResponse {
        try await self.client.execute(
            operation: "ListReferences", 
            path: "/referencestore/{referenceStoreId}/references", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves the metadata of one or more reference genomes in a reference store. For more information, see Creating a reference store in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of references to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - referenceStoreId: The references' reference store ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReferences(
        filter: ReferenceFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        referenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReferencesResponse {
        let input = ListReferencesRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            referenceStoreId: referenceStoreId
        )
        return try await self.listReferences(input, logger: logger)
    }

    /// Retrieves a list of your run caches and the metadata for each cache.
    @Sendable
    @inlinable
    public func listRunCaches(_ input: ListRunCachesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRunCachesResponse {
        try await self.client.execute(
            operation: "ListRunCaches", 
            path: "/runCache", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Retrieves a list of your run caches and the metadata for each cache.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - startingToken: Optional pagination token returned from a prior call to the ListRunCaches API operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRunCaches(
        maxResults: Int? = nil,
        startingToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRunCachesResponse {
        let input = ListRunCachesRequest(
            maxResults: maxResults, 
            startingToken: startingToken
        )
        return try await self.listRunCaches(input, logger: logger)
    }

    /// Retrieves a list of all run groups and returns the metadata for each run group.
    @Sendable
    @inlinable
    public func listRunGroups(_ input: ListRunGroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRunGroupsResponse {
        try await self.client.execute(
            operation: "ListRunGroups", 
            path: "/runGroup", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Retrieves a list of all run groups and returns the metadata for each run group.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of run groups to return in one page of results.
    ///   - name: The run groups' name.
    ///   - startingToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRunGroups(
        maxResults: Int? = nil,
        name: String? = nil,
        startingToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRunGroupsResponse {
        let input = ListRunGroupsRequest(
            maxResults: maxResults, 
            name: name, 
            startingToken: startingToken
        )
        return try await self.listRunGroups(input, logger: logger)
    }

    /// Returns a list of tasks and status information within their specified run. Use this operation to monitor runs and to identify which specific tasks have failed.
    @Sendable
    @inlinable
    public func listRunTasks(_ input: ListRunTasksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRunTasksResponse {
        try await self.client.execute(
            operation: "ListRunTasks", 
            path: "/run/{id}/task", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Returns a list of tasks and status information within their specified run. Use this operation to monitor runs and to identify which specific tasks have failed.
    ///
    /// Parameters:
    ///   - id: The run's ID.
    ///   - maxResults: The maximum number of run tasks to return in one page of results.
    ///   - startingToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - status: Filter the list by status.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRunTasks(
        id: String,
        maxResults: Int? = nil,
        startingToken: String? = nil,
        status: TaskStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRunTasksResponse {
        let input = ListRunTasksRequest(
            id: id, 
            maxResults: maxResults, 
            startingToken: startingToken, 
            status: status
        )
        return try await self.listRunTasks(input, logger: logger)
    }

    /// Retrieves a list of runs and returns each run's metadata and status. Amazon Web Services HealthOmics stores a configurable number of runs, as determined by service limits, that are available to the console and API. If the ListRuns response doesn't include specific runs that you expected, you can find all run logs in the CloudWatch logs. For more information about viewing the run logs, see CloudWatch logs in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func listRuns(_ input: ListRunsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRunsResponse {
        try await self.client.execute(
            operation: "ListRuns", 
            path: "/run", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Retrieves a list of runs and returns each run's metadata and status. Amazon Web Services HealthOmics stores a configurable number of runs, as determined by service limits, that are available to the console and API. If the ListRuns response doesn't include specific runs that you expected, you can find all run logs in the CloudWatch logs. For more information about viewing the run logs, see CloudWatch logs in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of runs to return in one page of results.
    ///   - name: Filter the list by run name.
    ///   - runGroupId: Filter the list by run group ID.
    ///   - startingToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - status: The status of a run.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRuns(
        maxResults: Int? = nil,
        name: String? = nil,
        runGroupId: String? = nil,
        startingToken: String? = nil,
        status: RunStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRunsResponse {
        let input = ListRunsRequest(
            maxResults: maxResults, 
            name: name, 
            runGroupId: runGroupId, 
            startingToken: startingToken, 
            status: status
        )
        return try await self.listRuns(input, logger: logger)
    }

    /// Retrieves a list of sequence stores and returns each sequence store's metadata. For more information, see Creating a HealthOmics sequence store in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func listSequenceStores(_ input: ListSequenceStoresRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSequenceStoresResponse {
        try await self.client.execute(
            operation: "ListSequenceStores", 
            path: "/sequencestores", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Retrieves a list of sequence stores and returns each sequence store's metadata. For more information, see Creating a HealthOmics sequence store in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of stores to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSequenceStores(
        filter: SequenceStoreFilter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSequenceStoresResponse {
        let input = ListSequenceStoresRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSequenceStores(input, logger: logger)
    }

    /// Retrieves the resource shares associated with an account. Use the filter parameter to retrieve a specific subset of the shares.
    @Sendable
    @inlinable
    public func listShares(_ input: ListSharesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSharesResponse {
        try await self.client.execute(
            operation: "ListShares", 
            path: "/shares", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Retrieves the resource shares associated with an account. Use the filter parameter to retrieve a specific subset of the shares.
    ///
    /// Parameters:
    ///   - filter: Attributes that you use to filter for a specific subset of resource shares.
    ///   - maxResults: The maximum number of shares to return in one page of results.
    ///   - nextToken: Next token returned in the response of a previous ListReadSetUploadPartsRequest call. Used to get the next page of results.
    ///   - resourceOwner: The account that owns the resource shares.
    ///   - logger: Logger use during operation
    @inlinable
    public func listShares(
        filter: Filter? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceOwner: ResourceOwner,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSharesResponse {
        let input = ListSharesRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceOwner: resourceOwner
        )
        return try await self.listShares(input, logger: logger)
    }

    /// Retrieves a list of tags for a resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "tags-", 
            logger: logger
        )
    }
    /// Retrieves a list of tags for a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The resource's ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Retrieves a list of variant import jobs.
    @Sendable
    @inlinable
    public func listVariantImportJobs(_ input: ListVariantImportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListVariantImportJobsResponse {
        try await self.client.execute(
            operation: "ListVariantImportJobs", 
            path: "/import/variants", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Retrieves a list of variant import jobs.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - ids: A list of job IDs.
    ///   - maxResults: The maximum number of import jobs to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listVariantImportJobs(
        filter: ListVariantImportJobsFilter? = nil,
        ids: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListVariantImportJobsResponse {
        let input = ListVariantImportJobsRequest(
            filter: filter, 
            ids: ids, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listVariantImportJobs(input, logger: logger)
    }

    /// Retrieves a list of variant stores.
    @Sendable
    @inlinable
    public func listVariantStores(_ input: ListVariantStoresRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListVariantStoresResponse {
        try await self.client.execute(
            operation: "ListVariantStores", 
            path: "/variantStores", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Retrieves a list of variant stores.
    ///
    /// Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - ids: A list of store IDs.
    ///   - maxResults: The maximum number of stores to return in one page of results.
    ///   - nextToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listVariantStores(
        filter: ListVariantStoresFilter? = nil,
        ids: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListVariantStoresResponse {
        let input = ListVariantStoresRequest(
            filter: filter, 
            ids: ids, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listVariantStores(input, logger: logger)
    }

    /// Lists the workflow versions for the specified workflow. For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func listWorkflowVersions(_ input: ListWorkflowVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWorkflowVersionsResponse {
        try await self.client.execute(
            operation: "ListWorkflowVersions", 
            path: "/workflow/{workflowId}/version", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Lists the workflow versions for the specified workflow. For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of workflows to return in one page of results.
    ///   - startingToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - type: The workflow type.
    ///   - workflowId: The workflow's ID. The workflowId is not the UUID.
    ///   - workflowOwnerId: The 12-digit account ID of the workflow owner. The workflow owner ID can be retrieved using the GetShare API operation. If you are the workflow owner, you do not need to include this ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWorkflowVersions(
        maxResults: Int? = nil,
        startingToken: String? = nil,
        type: WorkflowType? = nil,
        workflowId: String,
        workflowOwnerId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWorkflowVersionsResponse {
        let input = ListWorkflowVersionsRequest(
            maxResults: maxResults, 
            startingToken: startingToken, 
            type: type, 
            workflowId: workflowId, 
            workflowOwnerId: workflowOwnerId
        )
        return try await self.listWorkflowVersions(input, logger: logger)
    }

    /// Retrieves a list of existing workflows. You can filter for specific workflows by their name and type. Using the type parameter, specify PRIVATE to retrieve a list of private workflows or specify READY2RUN for a list of all Ready2Run workflows. If you do not specify the type of workflow, this operation returns a list of existing workflows.
    @Sendable
    @inlinable
    public func listWorkflows(_ input: ListWorkflowsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWorkflowsResponse {
        try await self.client.execute(
            operation: "ListWorkflows", 
            path: "/workflow", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Retrieves a list of existing workflows. You can filter for specific workflows by their name and type. Using the type parameter, specify PRIVATE to retrieve a list of private workflows or specify READY2RUN for a list of all Ready2Run workflows. If you do not specify the type of workflow, this operation returns a list of existing workflows.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of workflows to return in one page of results.
    ///   - name: Filter the list by workflow name.
    ///   - startingToken: Specify the pagination token from a previous request to retrieve the next page of results.
    ///   - type: Filter the list by workflow type.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWorkflows(
        maxResults: Int? = nil,
        name: String? = nil,
        startingToken: String? = nil,
        type: WorkflowType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWorkflowsResponse {
        let input = ListWorkflowsRequest(
            maxResults: maxResults, 
            name: name, 
            startingToken: startingToken, 
            type: type
        )
        return try await self.listWorkflows(input, logger: logger)
    }

    /// Adds an access policy to the specified store.
    @Sendable
    @inlinable
    public func putS3AccessPolicy(_ input: PutS3AccessPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutS3AccessPolicyResponse {
        try await self.client.execute(
            operation: "PutS3AccessPolicy", 
            path: "/s3accesspolicy/{s3AccessPointArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Adds an access policy to the specified store.
    ///
    /// Parameters:
    ///   - s3AccessPointArn: The S3 access point ARN where you want to put the access policy.
    ///   - s3AccessPolicy: The resource policy that controls S3 access to the store.
    ///   - logger: Logger use during operation
    @inlinable
    public func putS3AccessPolicy(
        s3AccessPointArn: String,
        s3AccessPolicy: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutS3AccessPolicyResponse {
        let input = PutS3AccessPolicyRequest(
            s3AccessPointArn: s3AccessPointArn, 
            s3AccessPolicy: s3AccessPolicy
        )
        return try await self.putS3AccessPolicy(input, logger: logger)
    }

    /// Starts an annotation import job.
    @Sendable
    @inlinable
    public func startAnnotationImportJob(_ input: StartAnnotationImportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartAnnotationImportResponse {
        try await self.client.execute(
            operation: "StartAnnotationImportJob", 
            path: "/import/annotation", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Starts an annotation import job.
    ///
    /// Parameters:
    ///   - annotationFields: The annotation schema generated by the parsed annotation data.
    ///   - destinationName: A destination annotation store for the job.
    ///   - formatOptions: Formatting options for the annotation file.
    ///   - items: Items to import.
    ///   - roleArn: A service role for the job.
    ///   - runLeftNormalization: The job's left normalization setting.
    ///   - versionName:  The name of the annotation store version.
    ///   - logger: Logger use during operation
    @inlinable
    public func startAnnotationImportJob(
        annotationFields: [String: String]? = nil,
        destinationName: String,
        formatOptions: FormatOptions? = nil,
        items: [AnnotationImportItemSource],
        roleArn: String,
        runLeftNormalization: Bool? = nil,
        versionName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartAnnotationImportResponse {
        let input = StartAnnotationImportRequest(
            annotationFields: annotationFields, 
            destinationName: destinationName, 
            formatOptions: formatOptions, 
            items: items, 
            roleArn: roleArn, 
            runLeftNormalization: runLeftNormalization, 
            versionName: versionName
        )
        return try await self.startAnnotationImportJob(input, logger: logger)
    }

    /// Activates an archived read set and returns its metadata in a JSON formatted output. AWS HealthOmics automatically archives unused read sets after 30 days. To monitor the status of your read set activation job, use the GetReadSetActivationJob operation. To learn more, see Activating read sets in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func startReadSetActivationJob(_ input: StartReadSetActivationJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartReadSetActivationJobResponse {
        try await self.client.execute(
            operation: "StartReadSetActivationJob", 
            path: "/sequencestore/{sequenceStoreId}/activationjob", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Activates an archived read set and returns its metadata in a JSON formatted output. AWS HealthOmics automatically archives unused read sets after 30 days. To monitor the status of your read set activation job, use the GetReadSetActivationJob operation. To learn more, see Activating read sets in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - clientToken: To ensure that jobs don't run multiple times, specify a unique token for each job.
    ///   - sequenceStoreId: The read set's sequence store ID.
    ///   - sources: The job's source files.
    ///   - logger: Logger use during operation
    @inlinable
    public func startReadSetActivationJob(
        clientToken: String? = nil,
        sequenceStoreId: String,
        sources: [StartReadSetActivationJobSourceItem],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartReadSetActivationJobResponse {
        let input = StartReadSetActivationJobRequest(
            clientToken: clientToken, 
            sequenceStoreId: sequenceStoreId, 
            sources: sources
        )
        return try await self.startReadSetActivationJob(input, logger: logger)
    }

    /// Starts a read set export job. When the export job is finished, the read set is exported to an Amazon S3 bucket which can be retrieved using the GetReadSetExportJob API operation. To monitor the status of the export job, use the ListReadSetExportJobs API operation.
    @Sendable
    @inlinable
    public func startReadSetExportJob(_ input: StartReadSetExportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartReadSetExportJobResponse {
        try await self.client.execute(
            operation: "StartReadSetExportJob", 
            path: "/sequencestore/{sequenceStoreId}/exportjob", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Starts a read set export job. When the export job is finished, the read set is exported to an Amazon S3 bucket which can be retrieved using the GetReadSetExportJob API operation. To monitor the status of the export job, use the ListReadSetExportJobs API operation.
    ///
    /// Parameters:
    ///   - clientToken: To ensure that jobs don't run multiple times, specify a unique token for each job.
    ///   - destination: A location for exported files in Amazon S3.
    ///   - roleArn: A service role for the job.
    ///   - sequenceStoreId: The read set's sequence store ID.
    ///   - sources: The job's source files.
    ///   - logger: Logger use during operation
    @inlinable
    public func startReadSetExportJob(
        clientToken: String? = nil,
        destination: String,
        roleArn: String,
        sequenceStoreId: String,
        sources: [ExportReadSet],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartReadSetExportJobResponse {
        let input = StartReadSetExportJobRequest(
            clientToken: clientToken, 
            destination: destination, 
            roleArn: roleArn, 
            sequenceStoreId: sequenceStoreId, 
            sources: sources
        )
        return try await self.startReadSetExportJob(input, logger: logger)
    }

    /// Imports a read set from the sequence store. Read set import jobs support a maximum of 100 read sets of different types. Monitor the progress of your read set import job by calling the GetReadSetImportJob API operation.
    @Sendable
    @inlinable
    public func startReadSetImportJob(_ input: StartReadSetImportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartReadSetImportJobResponse {
        try await self.client.execute(
            operation: "StartReadSetImportJob", 
            path: "/sequencestore/{sequenceStoreId}/importjob", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Imports a read set from the sequence store. Read set import jobs support a maximum of 100 read sets of different types. Monitor the progress of your read set import job by calling the GetReadSetImportJob API operation.
    ///
    /// Parameters:
    ///   - clientToken: To ensure that jobs don't run multiple times, specify a unique token for each job.
    ///   - roleArn: A service role for the job.
    ///   - sequenceStoreId: The read set's sequence store ID.
    ///   - sources: The job's source files.
    ///   - logger: Logger use during operation
    @inlinable
    public func startReadSetImportJob(
        clientToken: String? = nil,
        roleArn: String,
        sequenceStoreId: String,
        sources: [StartReadSetImportJobSourceItem],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartReadSetImportJobResponse {
        let input = StartReadSetImportJobRequest(
            clientToken: clientToken, 
            roleArn: roleArn, 
            sequenceStoreId: sequenceStoreId, 
            sources: sources
        )
        return try await self.startReadSetImportJob(input, logger: logger)
    }

    /// Imports a reference genome from Amazon S3 into a specified reference store. You can have multiple reference genomes in a reference store. You can only import reference genomes one at a time into each reference store. Monitor the status of your reference import job by using the GetReferenceImportJob API operation.
    @Sendable
    @inlinable
    public func startReferenceImportJob(_ input: StartReferenceImportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartReferenceImportJobResponse {
        try await self.client.execute(
            operation: "StartReferenceImportJob", 
            path: "/referencestore/{referenceStoreId}/importjob", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Imports a reference genome from Amazon S3 into a specified reference store. You can have multiple reference genomes in a reference store. You can only import reference genomes one at a time into each reference store. Monitor the status of your reference import job by using the GetReferenceImportJob API operation.
    ///
    /// Parameters:
    ///   - clientToken: To ensure that jobs don't run multiple times, specify a unique token for each job.
    ///   - referenceStoreId: The job's reference store ID.
    ///   - roleArn: A service role for the job.
    ///   - sources: The job's source files.
    ///   - logger: Logger use during operation
    @inlinable
    public func startReferenceImportJob(
        clientToken: String? = nil,
        referenceStoreId: String,
        roleArn: String,
        sources: [StartReferenceImportJobSourceItem],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartReferenceImportJobResponse {
        let input = StartReferenceImportJobRequest(
            clientToken: clientToken, 
            referenceStoreId: referenceStoreId, 
            roleArn: roleArn, 
            sources: sources
        )
        return try await self.startReferenceImportJob(input, logger: logger)
    }

    /// Starts a new run and returns details about the run, or duplicates an existing run. A run is a single invocation of a workflow. If you provide request IDs, Amazon Web Services HealthOmics identifies duplicate requests and starts the run only once. Monitor the progress of the run by calling the GetRun API operation. To start a new run, the following inputs are required:   A service role ARN (roleArn).   The run's workflow ID (workflowId, not the uuid or runId).   An Amazon S3 location (outputUri) where the run outputs will be saved.   All required workflow parameters (parameter), which can include optional parameters from the parameter template. The run cannot include any parameters that are not defined in the parameter template. To see all possible parameters, use the GetRun API operation.    For runs with a STATIC (default) storage type, specify the required storage capacity (in gibibytes). A storage capacity value is not required for runs that use DYNAMIC storage.    StartRun can also duplicate an existing run using the run's default values. You can modify these default values and/or add other optional inputs. To duplicate a run, the following inputs are required:   A service role ARN (roleArn).   The ID of the run to duplicate (runId).   An Amazon S3 location where the run outputs will be saved (outputUri).   To learn more about the optional parameters for StartRun, see Starting a run in the Amazon Web Services HealthOmics User Guide. Use the retentionMode input to control how long the metadata for each run is stored in CloudWatch. There are two retention modes:   Specify REMOVE to automatically remove the oldest runs when you reach the maximum service retention limit for runs. It is recommended that you use the REMOVE mode to initiate major run requests so that your runs do not fail when you reach the limit.   The retentionMode is set to the RETAIN mode by default, which allows you to manually remove runs after reaching the maximum service retention limit. Under this setting, you cannot create additional runs until you remove the excess runs.   To learn more about the retention modes, see Run retention mode in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func startRun(_ input: StartRunRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartRunResponse {
        try await self.client.execute(
            operation: "StartRun", 
            path: "/run", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Starts a new run and returns details about the run, or duplicates an existing run. A run is a single invocation of a workflow. If you provide request IDs, Amazon Web Services HealthOmics identifies duplicate requests and starts the run only once. Monitor the progress of the run by calling the GetRun API operation. To start a new run, the following inputs are required:   A service role ARN (roleArn).   The run's workflow ID (workflowId, not the uuid or runId).   An Amazon S3 location (outputUri) where the run outputs will be saved.   All required workflow parameters (parameter), which can include optional parameters from the parameter template. The run cannot include any parameters that are not defined in the parameter template. To see all possible parameters, use the GetRun API operation.    For runs with a STATIC (default) storage type, specify the required storage capacity (in gibibytes). A storage capacity value is not required for runs that use DYNAMIC storage.    StartRun can also duplicate an existing run using the run's default values. You can modify these default values and/or add other optional inputs. To duplicate a run, the following inputs are required:   A service role ARN (roleArn).   The ID of the run to duplicate (runId).   An Amazon S3 location where the run outputs will be saved (outputUri).   To learn more about the optional parameters for StartRun, see Starting a run in the Amazon Web Services HealthOmics User Guide. Use the retentionMode input to control how long the metadata for each run is stored in CloudWatch. There are two retention modes:   Specify REMOVE to automatically remove the oldest runs when you reach the maximum service retention limit for runs. It is recommended that you use the REMOVE mode to initiate major run requests so that your runs do not fail when you reach the limit.   The retentionMode is set to the RETAIN mode by default, which allows you to manually remove runs after reaching the maximum service retention limit. Under this setting, you cannot create additional runs until you remove the excess runs.   To learn more about the retention modes, see Run retention mode in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - cacheBehavior: The cache behavior for the run. You specify this value if you want to override the default behavior for the cache. You had set the default value when you created the cache. For more information, see Run cache behavior in the Amazon Web Services HealthOmics User Guide.
    ///   - cacheId: Identifier of the cache associated with this run. If you don't specify a cache ID, no task outputs are cached for this run.
    ///   - logLevel: A log level for the run.
    ///   - name: A name for the run. This is recommended to view and organize runs in the Amazon Web Services HealthOmics console and CloudWatch logs.
    ///   - outputUri: An output S3 URI for the run. The S3 bucket must be in the same region as the workflow. The role ARN must have permission to write to this S3 bucket.
    ///   - parameters: Parameters for the run. The run needs all required parameters and can include optional parameters. The run cannot include any parameters that are not defined in the parameter template. To retrieve parameters from the run, use the GetRun API operation.
    ///   - priority: Use the run priority (highest: 1) to establish the order of runs in a run group when you start a run. If multiple runs share the same priority, the run that was initiated first will have the higher priority. Runs that do not belong to a run group can be assigned a priority. The priorities of these runs are ranked among other runs that are not in a run group. For more information, see Run priority in the Amazon Web Services HealthOmics User Guide.
    ///   - requestId: An idempotency token used to dedupe retry requests so that duplicate runs are not created.
    ///   - retentionMode: The retention mode for the run. The default value is RETAIN.  Amazon Web Services HealthOmics stores a fixed number of runs that are available to the console and API. In the default mode (RETAIN), you need to remove runs manually when the number of run exceeds the maximum. If you set the retention mode to REMOVE, Amazon Web Services HealthOmics automatically removes runs (that have mode set to REMOVE) when the number of run exceeds the maximum. All run logs are available in CloudWatch logs, if you need information about a run that is no longer available to the API. For more information about retention mode, see Specifying run retention mode in the Amazon Web Services HealthOmics User Guide.
    ///   - roleArn: A service role for the run. The roleArn requires access to Amazon Web Services HealthOmics, S3, Cloudwatch logs, and EC2. An example roleArn is arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ. In this example, the AWS account ID is 123456789012 and the role name is omics-service-role-serviceRole-W8O1XMPL7QZ.
    ///   - runGroupId: The run's group ID. Use a run group to cap the compute resources (and number of concurrent runs) for the runs that you add to the run group.
    ///   - runId: The ID of a run to duplicate.
    ///   - storageCapacity: The STATIC storage capacity (in gibibytes, GiB) for this run. The default run storage capacity is 1200 GiB. If your requested storage capacity is unavailable, the system rounds up the value to the nearest 1200 GiB multiple. If the requested storage capacity is still unavailable, the system rounds up the value to the nearest 2400 GiB multiple. This field is not required if the storage type is DYNAMIC (the system ignores any value that you enter).
    ///   - storageType: The storage type for the run. If you set the storage type to DYNAMIC, Amazon Web Services HealthOmics dynamically scales the storage up or down, based on file system utilization. By default, the run uses STATIC storage type, which allocates a fixed amount of storage. For more information about DYNAMIC and STATIC storage, see Run storage types in the Amazon Web Services HealthOmics User Guide.
    ///   - tags: Tags for the run. You can add up to 50 tags per run. For more information, see Adding a tag in the Amazon Web Services HealthOmics User Guide.
    ///   - workflowId: The run's workflow ID. The workflowId is not the UUID.
    ///   - workflowOwnerId: The 12-digit account ID of the workflow owner that is used for running a shared workflow. The workflow owner ID can be retrieved using the GetShare API operation. If you are the workflow owner, you do not need to include this ID.
    ///   - workflowType: The run's workflow type. The workflowType must be specified if you are running a READY2RUN workflow. If you are running a PRIVATE workflow (default), you do not need to include the workflow type.
    ///   - workflowVersionName: The name of the workflow version. Use workflow versions to track and organize changes to the workflow. If your workflow has multiple versions, the run uses the default version unless you specify a version name. To learn more, see Workflow versioning in the Amazon Web Services HealthOmics User Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func startRun(
        cacheBehavior: CacheBehavior? = nil,
        cacheId: String? = nil,
        logLevel: RunLogLevel? = nil,
        name: String? = nil,
        outputUri: String,
        parameters: AWSDocument? = nil,
        priority: Int? = nil,
        requestId: String = StartRunRequest.idempotencyToken(),
        retentionMode: RunRetentionMode? = nil,
        roleArn: String,
        runGroupId: String? = nil,
        runId: String? = nil,
        storageCapacity: Int? = nil,
        storageType: StorageType? = nil,
        tags: [String: String]? = nil,
        workflowId: String? = nil,
        workflowOwnerId: String? = nil,
        workflowType: WorkflowType? = nil,
        workflowVersionName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartRunResponse {
        let input = StartRunRequest(
            cacheBehavior: cacheBehavior, 
            cacheId: cacheId, 
            logLevel: logLevel, 
            name: name, 
            outputUri: outputUri, 
            parameters: parameters, 
            priority: priority, 
            requestId: requestId, 
            retentionMode: retentionMode, 
            roleArn: roleArn, 
            runGroupId: runGroupId, 
            runId: runId, 
            storageCapacity: storageCapacity, 
            storageType: storageType, 
            tags: tags, 
            workflowId: workflowId, 
            workflowOwnerId: workflowOwnerId, 
            workflowType: workflowType, 
            workflowVersionName: workflowVersionName
        )
        return try await self.startRun(input, logger: logger)
    }

    /// Starts a variant import job.
    @Sendable
    @inlinable
    public func startVariantImportJob(_ input: StartVariantImportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartVariantImportResponse {
        try await self.client.execute(
            operation: "StartVariantImportJob", 
            path: "/import/variant", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Starts a variant import job.
    ///
    /// Parameters:
    ///   - annotationFields: The annotation schema generated by the parsed annotation data.
    ///   - destinationName: The destination variant store for the job.
    ///   - items: Items to import.
    ///   - roleArn: A service role for the job.
    ///   - runLeftNormalization: The job's left normalization setting.
    ///   - logger: Logger use during operation
    @inlinable
    public func startVariantImportJob(
        annotationFields: [String: String]? = nil,
        destinationName: String,
        items: [VariantImportItemSource],
        roleArn: String,
        runLeftNormalization: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartVariantImportResponse {
        let input = StartVariantImportRequest(
            annotationFields: annotationFields, 
            destinationName: destinationName, 
            items: items, 
            roleArn: roleArn, 
            runLeftNormalization: runLeftNormalization
        )
        return try await self.startVariantImportJob(input, logger: logger)
    }

    /// Tags a resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "tags-", 
            logger: logger
        )
    }
    /// Tags a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The resource's ARN.
    ///   - tags: Tags for the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "tags-", 
            logger: logger
        )
    }
    /// Removes tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The resource's ARN.
    ///   - tagKeys: Keys of tags to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates an annotation store.
    @Sendable
    @inlinable
    public func updateAnnotationStore(_ input: UpdateAnnotationStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAnnotationStoreResponse {
        try await self.client.execute(
            operation: "UpdateAnnotationStore", 
            path: "/annotationStore/{name}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Updates an annotation store.
    ///
    /// Parameters:
    ///   - description: A description for the store.
    ///   - name: A name for the store.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAnnotationStore(
        description: String? = nil,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAnnotationStoreResponse {
        let input = UpdateAnnotationStoreRequest(
            description: description, 
            name: name
        )
        return try await self.updateAnnotationStore(input, logger: logger)
    }

    ///  Updates the description of an annotation store version.
    @Sendable
    @inlinable
    public func updateAnnotationStoreVersion(_ input: UpdateAnnotationStoreVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAnnotationStoreVersionResponse {
        try await self.client.execute(
            operation: "UpdateAnnotationStoreVersion", 
            path: "/annotationStore/{name}/version/{versionName}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    ///  Updates the description of an annotation store version.
    ///
    /// Parameters:
    ///   - description:  The description of an annotation store.
    ///   - name:  The name of an annotation store.
    ///   - versionName:  The name of an annotation store version.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAnnotationStoreVersion(
        description: String? = nil,
        name: String,
        versionName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAnnotationStoreVersionResponse {
        let input = UpdateAnnotationStoreVersionRequest(
            description: description, 
            name: name, 
            versionName: versionName
        )
        return try await self.updateAnnotationStoreVersion(input, logger: logger)
    }

    /// Updates a run cache using its ID and returns a response with no body if the operation is successful. You can update the run cache description, name, or the default run cache behavior with CACHE_ON_FAILURE or CACHE_ALWAYS. To confirm that your run cache settings have been properly updated, use the GetRunCache API operation. For more information, see How call caching works in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func updateRunCache(_ input: UpdateRunCacheRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRunCache", 
            path: "/runCache/{id}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Updates a run cache using its ID and returns a response with no body if the operation is successful. You can update the run cache description, name, or the default run cache behavior with CACHE_ON_FAILURE or CACHE_ALWAYS. To confirm that your run cache settings have been properly updated, use the GetRunCache API operation. For more information, see How call caching works in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - cacheBehavior: Update the default run cache behavior.
    ///   - description: Update the run cache description.
    ///   - id: The identifier of the run cache you want to update.
    ///   - name: Update the name of the run cache.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRunCache(
        cacheBehavior: CacheBehavior? = nil,
        description: String? = nil,
        id: String,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRunCacheRequest(
            cacheBehavior: cacheBehavior, 
            description: description, 
            id: id, 
            name: name
        )
        return try await self.updateRunCache(input, logger: logger)
    }

    /// Updates the settings of a run group and returns a response with no body if the operation is successful. You can update the following settings with UpdateRunGroup:   Maximum number of CPUs   Run time (measured in minutes)   Number of GPUs   Number of concurrent runs   Group name   To confirm that the settings have been successfully updated, use the ListRunGroups or GetRunGroup API operations to verify that the desired changes have been made.
    @Sendable
    @inlinable
    public func updateRunGroup(_ input: UpdateRunGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRunGroup", 
            path: "/runGroup/{id}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Updates the settings of a run group and returns a response with no body if the operation is successful. You can update the following settings with UpdateRunGroup:   Maximum number of CPUs   Run time (measured in minutes)   Number of GPUs   Number of concurrent runs   Group name   To confirm that the settings have been successfully updated, use the ListRunGroups or GetRunGroup API operations to verify that the desired changes have been made.
    ///
    /// Parameters:
    ///   - id: The group's ID.
    ///   - maxCpus: The maximum number of CPUs to use.
    ///   - maxDuration: A maximum run time for the group in minutes.
    ///   - maxGpus: The maximum GPUs that can be used by a run group.
    ///   - maxRuns: The maximum number of concurrent runs for the group.
    ///   - name: A name for the group.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRunGroup(
        id: String,
        maxCpus: Int? = nil,
        maxDuration: Int? = nil,
        maxGpus: Int? = nil,
        maxRuns: Int? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRunGroupRequest(
            id: id, 
            maxCpus: maxCpus, 
            maxDuration: maxDuration, 
            maxGpus: maxGpus, 
            maxRuns: maxRuns, 
            name: name
        )
        return try await self.updateRunGroup(input, logger: logger)
    }

    /// Update one or more parameters for the sequence store.
    @Sendable
    @inlinable
    public func updateSequenceStore(_ input: UpdateSequenceStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSequenceStoreResponse {
        try await self.client.execute(
            operation: "UpdateSequenceStore", 
            path: "/sequencestore/{id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "control-storage-", 
            logger: logger
        )
    }
    /// Update one or more parameters for the sequence store.
    ///
    /// Parameters:
    ///   - clientToken: To ensure that requests don't run multiple times, specify a unique token for each request.
    ///   - description: A description for the sequence store.
    ///   - fallbackLocation: The S3 URI of a bucket and folder to store Read Sets that fail to upload.
    ///   - id: The ID of the sequence store.
    ///   - name: A name for the sequence store.
    ///   - propagatedSetLevelTags: The tags keys to propagate to the S3 objects associated with read sets in the sequence store.
    ///   - s3AccessConfig: S3 access configuration parameters.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSequenceStore(
        clientToken: String? = UpdateSequenceStoreRequest.idempotencyToken(),
        description: String? = nil,
        fallbackLocation: String? = nil,
        id: String,
        name: String? = nil,
        propagatedSetLevelTags: [String]? = nil,
        s3AccessConfig: S3AccessConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSequenceStoreResponse {
        let input = UpdateSequenceStoreRequest(
            clientToken: clientToken, 
            description: description, 
            fallbackLocation: fallbackLocation, 
            id: id, 
            name: name, 
            propagatedSetLevelTags: propagatedSetLevelTags, 
            s3AccessConfig: s3AccessConfig
        )
        return try await self.updateSequenceStore(input, logger: logger)
    }

    /// Updates a variant store.
    @Sendable
    @inlinable
    public func updateVariantStore(_ input: UpdateVariantStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateVariantStoreResponse {
        try await self.client.execute(
            operation: "UpdateVariantStore", 
            path: "/variantStore/{name}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "analytics-", 
            logger: logger
        )
    }
    /// Updates a variant store.
    ///
    /// Parameters:
    ///   - description: A description for the store.
    ///   - name: A name for the store.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateVariantStore(
        description: String? = nil,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateVariantStoreResponse {
        let input = UpdateVariantStoreRequest(
            description: description, 
            name: name
        )
        return try await self.updateVariantStore(input, logger: logger)
    }

    /// Updates information about a workflow. You can update the following workflow information:   Name   Description   Default storage type   Default storage capacity (with workflow ID)   This operation returns a response with no body if the operation is successful. You can check the workflow updates by calling the GetWorkflow API operation. For more information, see Update a private workflow in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func updateWorkflow(_ input: UpdateWorkflowRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateWorkflow", 
            path: "/workflow/{id}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Updates information about a workflow. You can update the following workflow information:   Name   Description   Default storage type   Default storage capacity (with workflow ID)   This operation returns a response with no body if the operation is successful. You can check the workflow updates by calling the GetWorkflow API operation. For more information, see Update a private workflow in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - description: A description for the workflow.
    ///   - id: The workflow's ID.
    ///   - name: A name for the workflow.
    ///   - readmeMarkdown: The markdown content for the workflow's README file. This provides documentation and usage information for users of the workflow.
    ///   - storageCapacity: The default static storage capacity (in gibibytes) for runs that use this workflow or workflow version.
    ///   - storageType: The default storage type for runs that use this workflow. STATIC storage allocates a fixed amount of storage. DYNAMIC storage dynamically scales the storage up or down, based on file system utilization. For more information about static and dynamic storage, see Running workflows in the Amazon Web Services HealthOmics User Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateWorkflow(
        description: String? = nil,
        id: String,
        name: String? = nil,
        readmeMarkdown: String? = nil,
        storageCapacity: Int? = nil,
        storageType: StorageType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateWorkflowRequest(
            description: description, 
            id: id, 
            name: name, 
            readmeMarkdown: readmeMarkdown, 
            storageCapacity: storageCapacity, 
            storageType: storageType
        )
        return try await self.updateWorkflow(input, logger: logger)
    }

    /// Updates information about the workflow version. For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func updateWorkflowVersion(_ input: UpdateWorkflowVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateWorkflowVersion", 
            path: "/workflow/{workflowId}/version/{versionName}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "workflows-", 
            logger: logger
        )
    }
    /// Updates information about the workflow version. For more information, see Workflow versioning in Amazon Web Services HealthOmics in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - description: Description of the workflow version.
    ///   - readmeMarkdown: The markdown content for the workflow version's README file. This provides documentation and usage information for users of this specific workflow version.
    ///   - storageCapacity: The default static storage capacity (in gibibytes) for runs that use this workflow version. The storageCapacity can be overwritten at run time. The storage capacity is not required for runs with a DYNAMIC storage type.
    ///   - storageType: The default storage type for runs that use this workflow version. The storageType can be overridden at run time. DYNAMIC storage dynamically scales the storage up or down, based on file system utilization. STATIC storage allocates a fixed amount of storage. For more information about dynamic and static storage types, see Run storage types in the in the Amazon Web Services HealthOmics User Guide .
    ///   - versionName: The name of the workflow version.
    ///   - workflowId: The workflow's ID. The workflowId is not the UUID.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateWorkflowVersion(
        description: String? = nil,
        readmeMarkdown: String? = nil,
        storageCapacity: Int? = nil,
        storageType: StorageType? = nil,
        versionName: String,
        workflowId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateWorkflowVersionRequest(
            description: description, 
            readmeMarkdown: readmeMarkdown, 
            storageCapacity: storageCapacity, 
            storageType: storageType, 
            versionName: versionName, 
            workflowId: workflowId
        )
        return try await self.updateWorkflowVersion(input, logger: logger)
    }

    /// Uploads a specific part of a read set into a sequence store. When you a upload a read set part with a part number that already exists, the new part replaces the existing one. This operation returns a JSON formatted response containing a string identifier that is used to confirm that parts are being added to the intended upload. For more information, see Direct upload to a sequence store in the Amazon Web Services HealthOmics User Guide.
    @Sendable
    @inlinable
    public func uploadReadSetPart(_ input: UploadReadSetPartRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UploadReadSetPartResponse {
        try await self.client.execute(
            operation: "UploadReadSetPart", 
            path: "/sequencestore/{sequenceStoreId}/upload/{uploadId}/part", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            hostPrefix: "storage-", 
            logger: logger
        )
    }
    /// Uploads a specific part of a read set into a sequence store. When you a upload a read set part with a part number that already exists, the new part replaces the existing one. This operation returns a JSON formatted response containing a string identifier that is used to confirm that parts are being added to the intended upload. For more information, see Direct upload to a sequence store in the Amazon Web Services HealthOmics User Guide.
    ///
    /// Parameters:
    ///   - partNumber: The number of the part being uploaded.
    ///   - partSource: The source file for an upload part.
    ///   - payload: The read set data to upload for a part.
    ///   - sequenceStoreId: The Sequence Store ID used for the multipart upload.
    ///   - uploadId: The ID for the initiated multipart upload.
    ///   - logger: Logger use during operation
    @inlinable
    public func uploadReadSetPart(
        partNumber: Int,
        partSource: ReadSetPartSource,
        payload: AWSHTTPBody,
        sequenceStoreId: String,
        uploadId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UploadReadSetPartResponse {
        let input = UploadReadSetPartRequest(
            partNumber: partNumber, 
            partSource: partSource, 
            payload: payload, 
            sequenceStoreId: sequenceStoreId, 
            uploadId: uploadId
        )
        return try await self.uploadReadSetPart(input, logger: logger)
    }
}

extension Omics {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Omics, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Omics {
    /// Return PaginatorSequence for operation ``listAnnotationImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAnnotationImportJobsPaginator(
        _ input: ListAnnotationImportJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAnnotationImportJobsRequest, ListAnnotationImportJobsResponse> {
        return .init(
            input: input,
            command: self.listAnnotationImportJobs,
            inputKey: \ListAnnotationImportJobsRequest.nextToken,
            outputKey: \ListAnnotationImportJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAnnotationImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - ids: IDs of annotation import jobs to retrieve.
    ///   - maxResults: The maximum number of jobs to return in one page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAnnotationImportJobsPaginator(
        filter: ListAnnotationImportJobsFilter? = nil,
        ids: [String]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAnnotationImportJobsRequest, ListAnnotationImportJobsResponse> {
        let input = ListAnnotationImportJobsRequest(
            filter: filter, 
            ids: ids, 
            maxResults: maxResults
        )
        return self.listAnnotationImportJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAnnotationStoreVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAnnotationStoreVersionsPaginator(
        _ input: ListAnnotationStoreVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAnnotationStoreVersionsRequest, ListAnnotationStoreVersionsResponse> {
        return .init(
            input: input,
            command: self.listAnnotationStoreVersions,
            inputKey: \ListAnnotationStoreVersionsRequest.nextToken,
            outputKey: \ListAnnotationStoreVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAnnotationStoreVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter:  A filter to apply to the list of annotation store versions.
    ///   - maxResults:  The maximum number of annotation store versions to return in one page of results.
    ///   - name:  The name of an annotation store.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAnnotationStoreVersionsPaginator(
        filter: ListAnnotationStoreVersionsFilter? = nil,
        maxResults: Int? = nil,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAnnotationStoreVersionsRequest, ListAnnotationStoreVersionsResponse> {
        let input = ListAnnotationStoreVersionsRequest(
            filter: filter, 
            maxResults: maxResults, 
            name: name
        )
        return self.listAnnotationStoreVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAnnotationStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAnnotationStoresPaginator(
        _ input: ListAnnotationStoresRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAnnotationStoresRequest, ListAnnotationStoresResponse> {
        return .init(
            input: input,
            command: self.listAnnotationStores,
            inputKey: \ListAnnotationStoresRequest.nextToken,
            outputKey: \ListAnnotationStoresResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAnnotationStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - ids: IDs of stores to list.
    ///   - maxResults: The maximum number of stores to return in one page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAnnotationStoresPaginator(
        filter: ListAnnotationStoresFilter? = nil,
        ids: [String]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAnnotationStoresRequest, ListAnnotationStoresResponse> {
        let input = ListAnnotationStoresRequest(
            filter: filter, 
            ids: ids, 
            maxResults: maxResults
        )
        return self.listAnnotationStoresPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMultipartReadSetUploads(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMultipartReadSetUploadsPaginator(
        _ input: ListMultipartReadSetUploadsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMultipartReadSetUploadsRequest, ListMultipartReadSetUploadsResponse> {
        return .init(
            input: input,
            command: self.listMultipartReadSetUploads,
            inputKey: \ListMultipartReadSetUploadsRequest.nextToken,
            outputKey: \ListMultipartReadSetUploadsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMultipartReadSetUploads(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of multipart uploads returned in a page.
    ///   - sequenceStoreId: The Sequence Store ID used for the multipart uploads.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMultipartReadSetUploadsPaginator(
        maxResults: Int? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMultipartReadSetUploadsRequest, ListMultipartReadSetUploadsResponse> {
        let input = ListMultipartReadSetUploadsRequest(
            maxResults: maxResults, 
            sequenceStoreId: sequenceStoreId
        )
        return self.listMultipartReadSetUploadsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReadSetActivationJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetActivationJobsPaginator(
        _ input: ListReadSetActivationJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReadSetActivationJobsRequest, ListReadSetActivationJobsResponse> {
        return .init(
            input: input,
            command: self.listReadSetActivationJobs,
            inputKey: \ListReadSetActivationJobsRequest.nextToken,
            outputKey: \ListReadSetActivationJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReadSetActivationJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of read set activation jobs to return in one page of results.
    ///   - sequenceStoreId: The read set's sequence store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetActivationJobsPaginator(
        filter: ActivateReadSetFilter? = nil,
        maxResults: Int? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReadSetActivationJobsRequest, ListReadSetActivationJobsResponse> {
        let input = ListReadSetActivationJobsRequest(
            filter: filter, 
            maxResults: maxResults, 
            sequenceStoreId: sequenceStoreId
        )
        return self.listReadSetActivationJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReadSetExportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetExportJobsPaginator(
        _ input: ListReadSetExportJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReadSetExportJobsRequest, ListReadSetExportJobsResponse> {
        return .init(
            input: input,
            command: self.listReadSetExportJobs,
            inputKey: \ListReadSetExportJobsRequest.nextToken,
            outputKey: \ListReadSetExportJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReadSetExportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of jobs to return in one page of results.
    ///   - sequenceStoreId: The jobs' sequence store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetExportJobsPaginator(
        filter: ExportReadSetFilter? = nil,
        maxResults: Int? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReadSetExportJobsRequest, ListReadSetExportJobsResponse> {
        let input = ListReadSetExportJobsRequest(
            filter: filter, 
            maxResults: maxResults, 
            sequenceStoreId: sequenceStoreId
        )
        return self.listReadSetExportJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReadSetImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetImportJobsPaginator(
        _ input: ListReadSetImportJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReadSetImportJobsRequest, ListReadSetImportJobsResponse> {
        return .init(
            input: input,
            command: self.listReadSetImportJobs,
            inputKey: \ListReadSetImportJobsRequest.nextToken,
            outputKey: \ListReadSetImportJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReadSetImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of jobs to return in one page of results.
    ///   - sequenceStoreId: The jobs' sequence store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetImportJobsPaginator(
        filter: ImportReadSetFilter? = nil,
        maxResults: Int? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReadSetImportJobsRequest, ListReadSetImportJobsResponse> {
        let input = ListReadSetImportJobsRequest(
            filter: filter, 
            maxResults: maxResults, 
            sequenceStoreId: sequenceStoreId
        )
        return self.listReadSetImportJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReadSetUploadParts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetUploadPartsPaginator(
        _ input: ListReadSetUploadPartsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReadSetUploadPartsRequest, ListReadSetUploadPartsResponse> {
        return .init(
            input: input,
            command: self.listReadSetUploadParts,
            inputKey: \ListReadSetUploadPartsRequest.nextToken,
            outputKey: \ListReadSetUploadPartsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReadSetUploadParts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: Attributes used to filter for a specific subset of read set part uploads.
    ///   - maxResults: The maximum number of read set upload parts returned in a page.
    ///   - partSource: The source file for the upload part.
    ///   - sequenceStoreId: The Sequence Store ID used for the multipart uploads.
    ///   - uploadId: The ID for the initiated multipart upload.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetUploadPartsPaginator(
        filter: ReadSetUploadPartListFilter? = nil,
        maxResults: Int? = nil,
        partSource: ReadSetPartSource,
        sequenceStoreId: String,
        uploadId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReadSetUploadPartsRequest, ListReadSetUploadPartsResponse> {
        let input = ListReadSetUploadPartsRequest(
            filter: filter, 
            maxResults: maxResults, 
            partSource: partSource, 
            sequenceStoreId: sequenceStoreId, 
            uploadId: uploadId
        )
        return self.listReadSetUploadPartsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReadSets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetsPaginator(
        _ input: ListReadSetsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReadSetsRequest, ListReadSetsResponse> {
        return .init(
            input: input,
            command: self.listReadSets,
            inputKey: \ListReadSetsRequest.nextToken,
            outputKey: \ListReadSetsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReadSets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of read sets to return in one page of results.
    ///   - sequenceStoreId: The jobs' sequence store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadSetsPaginator(
        filter: ReadSetFilter? = nil,
        maxResults: Int? = nil,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReadSetsRequest, ListReadSetsResponse> {
        let input = ListReadSetsRequest(
            filter: filter, 
            maxResults: maxResults, 
            sequenceStoreId: sequenceStoreId
        )
        return self.listReadSetsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReferenceImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReferenceImportJobsPaginator(
        _ input: ListReferenceImportJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReferenceImportJobsRequest, ListReferenceImportJobsResponse> {
        return .init(
            input: input,
            command: self.listReferenceImportJobs,
            inputKey: \ListReferenceImportJobsRequest.nextToken,
            outputKey: \ListReferenceImportJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReferenceImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of jobs to return in one page of results.
    ///   - referenceStoreId: The job's reference store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReferenceImportJobsPaginator(
        filter: ImportReferenceFilter? = nil,
        maxResults: Int? = nil,
        referenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReferenceImportJobsRequest, ListReferenceImportJobsResponse> {
        let input = ListReferenceImportJobsRequest(
            filter: filter, 
            maxResults: maxResults, 
            referenceStoreId: referenceStoreId
        )
        return self.listReferenceImportJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReferenceStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReferenceStoresPaginator(
        _ input: ListReferenceStoresRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReferenceStoresRequest, ListReferenceStoresResponse> {
        return .init(
            input: input,
            command: self.listReferenceStores,
            inputKey: \ListReferenceStoresRequest.nextToken,
            outputKey: \ListReferenceStoresResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReferenceStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of stores to return in one page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReferenceStoresPaginator(
        filter: ReferenceStoreFilter? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReferenceStoresRequest, ListReferenceStoresResponse> {
        let input = ListReferenceStoresRequest(
            filter: filter, 
            maxResults: maxResults
        )
        return self.listReferenceStoresPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReferences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReferencesPaginator(
        _ input: ListReferencesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReferencesRequest, ListReferencesResponse> {
        return .init(
            input: input,
            command: self.listReferences,
            inputKey: \ListReferencesRequest.nextToken,
            outputKey: \ListReferencesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReferences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of references to return in one page of results.
    ///   - referenceStoreId: The references' reference store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReferencesPaginator(
        filter: ReferenceFilter? = nil,
        maxResults: Int? = nil,
        referenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReferencesRequest, ListReferencesResponse> {
        let input = ListReferencesRequest(
            filter: filter, 
            maxResults: maxResults, 
            referenceStoreId: referenceStoreId
        )
        return self.listReferencesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRunCaches(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunCachesPaginator(
        _ input: ListRunCachesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRunCachesRequest, ListRunCachesResponse> {
        return .init(
            input: input,
            command: self.listRunCaches,
            inputKey: \ListRunCachesRequest.startingToken,
            outputKey: \ListRunCachesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRunCaches(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunCachesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRunCachesRequest, ListRunCachesResponse> {
        let input = ListRunCachesRequest(
            maxResults: maxResults
        )
        return self.listRunCachesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRunGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunGroupsPaginator(
        _ input: ListRunGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRunGroupsRequest, ListRunGroupsResponse> {
        return .init(
            input: input,
            command: self.listRunGroups,
            inputKey: \ListRunGroupsRequest.startingToken,
            outputKey: \ListRunGroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRunGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of run groups to return in one page of results.
    ///   - name: The run groups' name.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunGroupsPaginator(
        maxResults: Int? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRunGroupsRequest, ListRunGroupsResponse> {
        let input = ListRunGroupsRequest(
            maxResults: maxResults, 
            name: name
        )
        return self.listRunGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRunTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunTasksPaginator(
        _ input: ListRunTasksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRunTasksRequest, ListRunTasksResponse> {
        return .init(
            input: input,
            command: self.listRunTasks,
            inputKey: \ListRunTasksRequest.startingToken,
            outputKey: \ListRunTasksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRunTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The run's ID.
    ///   - maxResults: The maximum number of run tasks to return in one page of results.
    ///   - status: Filter the list by status.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunTasksPaginator(
        id: String,
        maxResults: Int? = nil,
        status: TaskStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRunTasksRequest, ListRunTasksResponse> {
        let input = ListRunTasksRequest(
            id: id, 
            maxResults: maxResults, 
            status: status
        )
        return self.listRunTasksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRuns(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunsPaginator(
        _ input: ListRunsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRunsRequest, ListRunsResponse> {
        return .init(
            input: input,
            command: self.listRuns,
            inputKey: \ListRunsRequest.startingToken,
            outputKey: \ListRunsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRuns(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of runs to return in one page of results.
    ///   - name: Filter the list by run name.
    ///   - runGroupId: Filter the list by run group ID.
    ///   - status: The status of a run.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRunsPaginator(
        maxResults: Int? = nil,
        name: String? = nil,
        runGroupId: String? = nil,
        status: RunStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRunsRequest, ListRunsResponse> {
        let input = ListRunsRequest(
            maxResults: maxResults, 
            name: name, 
            runGroupId: runGroupId, 
            status: status
        )
        return self.listRunsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSequenceStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSequenceStoresPaginator(
        _ input: ListSequenceStoresRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSequenceStoresRequest, ListSequenceStoresResponse> {
        return .init(
            input: input,
            command: self.listSequenceStores,
            inputKey: \ListSequenceStoresRequest.nextToken,
            outputKey: \ListSequenceStoresResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSequenceStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - maxResults: The maximum number of stores to return in one page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSequenceStoresPaginator(
        filter: SequenceStoreFilter? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSequenceStoresRequest, ListSequenceStoresResponse> {
        let input = ListSequenceStoresRequest(
            filter: filter, 
            maxResults: maxResults
        )
        return self.listSequenceStoresPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listShares(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSharesPaginator(
        _ input: ListSharesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSharesRequest, ListSharesResponse> {
        return .init(
            input: input,
            command: self.listShares,
            inputKey: \ListSharesRequest.nextToken,
            outputKey: \ListSharesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listShares(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: Attributes that you use to filter for a specific subset of resource shares.
    ///   - maxResults: The maximum number of shares to return in one page of results.
    ///   - resourceOwner: The account that owns the resource shares.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSharesPaginator(
        filter: Filter? = nil,
        maxResults: Int? = nil,
        resourceOwner: ResourceOwner,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSharesRequest, ListSharesResponse> {
        let input = ListSharesRequest(
            filter: filter, 
            maxResults: maxResults, 
            resourceOwner: resourceOwner
        )
        return self.listSharesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listVariantImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listVariantImportJobsPaginator(
        _ input: ListVariantImportJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListVariantImportJobsRequest, ListVariantImportJobsResponse> {
        return .init(
            input: input,
            command: self.listVariantImportJobs,
            inputKey: \ListVariantImportJobsRequest.nextToken,
            outputKey: \ListVariantImportJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listVariantImportJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - ids: A list of job IDs.
    ///   - maxResults: The maximum number of import jobs to return in one page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listVariantImportJobsPaginator(
        filter: ListVariantImportJobsFilter? = nil,
        ids: [String]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListVariantImportJobsRequest, ListVariantImportJobsResponse> {
        let input = ListVariantImportJobsRequest(
            filter: filter, 
            ids: ids, 
            maxResults: maxResults
        )
        return self.listVariantImportJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listVariantStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listVariantStoresPaginator(
        _ input: ListVariantStoresRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListVariantStoresRequest, ListVariantStoresResponse> {
        return .init(
            input: input,
            command: self.listVariantStores,
            inputKey: \ListVariantStoresRequest.nextToken,
            outputKey: \ListVariantStoresResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listVariantStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: A filter to apply to the list.
    ///   - ids: A list of store IDs.
    ///   - maxResults: The maximum number of stores to return in one page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listVariantStoresPaginator(
        filter: ListVariantStoresFilter? = nil,
        ids: [String]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListVariantStoresRequest, ListVariantStoresResponse> {
        let input = ListVariantStoresRequest(
            filter: filter, 
            ids: ids, 
            maxResults: maxResults
        )
        return self.listVariantStoresPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWorkflowVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowVersionsPaginator(
        _ input: ListWorkflowVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWorkflowVersionsRequest, ListWorkflowVersionsResponse> {
        return .init(
            input: input,
            command: self.listWorkflowVersions,
            inputKey: \ListWorkflowVersionsRequest.startingToken,
            outputKey: \ListWorkflowVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWorkflowVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of workflows to return in one page of results.
    ///   - type: The workflow type.
    ///   - workflowId: The workflow's ID. The workflowId is not the UUID.
    ///   - workflowOwnerId: The 12-digit account ID of the workflow owner. The workflow owner ID can be retrieved using the GetShare API operation. If you are the workflow owner, you do not need to include this ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowVersionsPaginator(
        maxResults: Int? = nil,
        type: WorkflowType? = nil,
        workflowId: String,
        workflowOwnerId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWorkflowVersionsRequest, ListWorkflowVersionsResponse> {
        let input = ListWorkflowVersionsRequest(
            maxResults: maxResults, 
            type: type, 
            workflowId: workflowId, 
            workflowOwnerId: workflowOwnerId
        )
        return self.listWorkflowVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWorkflows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowsPaginator(
        _ input: ListWorkflowsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWorkflowsRequest, ListWorkflowsResponse> {
        return .init(
            input: input,
            command: self.listWorkflows,
            inputKey: \ListWorkflowsRequest.startingToken,
            outputKey: \ListWorkflowsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWorkflows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of workflows to return in one page of results.
    ///   - name: Filter the list by workflow name.
    ///   - type: Filter the list by workflow type.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkflowsPaginator(
        maxResults: Int? = nil,
        name: String? = nil,
        type: WorkflowType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWorkflowsRequest, ListWorkflowsResponse> {
        let input = ListWorkflowsRequest(
            maxResults: maxResults, 
            name: name, 
            type: type
        )
        return self.listWorkflowsPaginator(input, logger: logger)
    }
}

extension Omics.ListAnnotationImportJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListAnnotationImportJobsRequest {
        return .init(
            filter: self.filter,
            ids: self.ids,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Omics.ListAnnotationStoreVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListAnnotationStoreVersionsRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            name: self.name,
            nextToken: token
        )
    }
}

extension Omics.ListAnnotationStoresRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListAnnotationStoresRequest {
        return .init(
            filter: self.filter,
            ids: self.ids,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Omics.ListMultipartReadSetUploadsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListMultipartReadSetUploadsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            sequenceStoreId: self.sequenceStoreId
        )
    }
}

extension Omics.ListReadSetActivationJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListReadSetActivationJobsRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token,
            sequenceStoreId: self.sequenceStoreId
        )
    }
}

extension Omics.ListReadSetExportJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListReadSetExportJobsRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token,
            sequenceStoreId: self.sequenceStoreId
        )
    }
}

extension Omics.ListReadSetImportJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListReadSetImportJobsRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token,
            sequenceStoreId: self.sequenceStoreId
        )
    }
}

extension Omics.ListReadSetUploadPartsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListReadSetUploadPartsRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token,
            partSource: self.partSource,
            sequenceStoreId: self.sequenceStoreId,
            uploadId: self.uploadId
        )
    }
}

extension Omics.ListReadSetsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListReadSetsRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token,
            sequenceStoreId: self.sequenceStoreId
        )
    }
}

extension Omics.ListReferenceImportJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListReferenceImportJobsRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token,
            referenceStoreId: self.referenceStoreId
        )
    }
}

extension Omics.ListReferenceStoresRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListReferenceStoresRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Omics.ListReferencesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListReferencesRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token,
            referenceStoreId: self.referenceStoreId
        )
    }
}

extension Omics.ListRunCachesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListRunCachesRequest {
        return .init(
            maxResults: self.maxResults,
            startingToken: token
        )
    }
}

extension Omics.ListRunGroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListRunGroupsRequest {
        return .init(
            maxResults: self.maxResults,
            name: self.name,
            startingToken: token
        )
    }
}

extension Omics.ListRunTasksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListRunTasksRequest {
        return .init(
            id: self.id,
            maxResults: self.maxResults,
            startingToken: token,
            status: self.status
        )
    }
}

extension Omics.ListRunsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListRunsRequest {
        return .init(
            maxResults: self.maxResults,
            name: self.name,
            runGroupId: self.runGroupId,
            startingToken: token,
            status: self.status
        )
    }
}

extension Omics.ListSequenceStoresRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListSequenceStoresRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Omics.ListSharesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListSharesRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token,
            resourceOwner: self.resourceOwner
        )
    }
}

extension Omics.ListVariantImportJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListVariantImportJobsRequest {
        return .init(
            filter: self.filter,
            ids: self.ids,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Omics.ListVariantStoresRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListVariantStoresRequest {
        return .init(
            filter: self.filter,
            ids: self.ids,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Omics.ListWorkflowVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListWorkflowVersionsRequest {
        return .init(
            maxResults: self.maxResults,
            startingToken: token,
            type: self.type,
            workflowId: self.workflowId,
            workflowOwnerId: self.workflowOwnerId
        )
    }
}

extension Omics.ListWorkflowsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Omics.ListWorkflowsRequest {
        return .init(
            maxResults: self.maxResults,
            name: self.name,
            startingToken: token,
            type: self.type
        )
    }
}

// MARK: Waiters

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Omics {
    /// Waiter for operation ``getAnnotationImportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationImportJobCreated(
        _ input: GetAnnotationImportRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetAnnotationImportRequest, _>(
            acceptors: [
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "SUBMITTED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "IN_PROGRESS")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "CANCELLED")),
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "COMPLETED")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getAnnotationImportJob
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getAnnotationImportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - jobId: The job's ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationImportJobCreated(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetAnnotationImportRequest(
            jobId: jobId
        )
        try await self.waitUntilAnnotationImportJobCreated(input, logger: logger)
    }

    /// Waiter for operation ``getAnnotationStore(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationStoreCreated(
        _ input: GetAnnotationStoreRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetAnnotationStoreRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "ACTIVE")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "CREATING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "UPDATING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getAnnotationStore
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getAnnotationStore(_:logger:)``.
    ///
    /// - Parameters:
    ///   - name: The store's name.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationStoreCreated(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetAnnotationStoreRequest(
            name: name
        )
        try await self.waitUntilAnnotationStoreCreated(input, logger: logger)
    }

    /// Waiter for operation ``getAnnotationStore(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationStoreDeleted(
        _ input: GetAnnotationStoreRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetAnnotationStoreRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "DELETED")),
                .init(state: .success, matcher: AWSErrorCodeMatcher("ResourceNotFoundException")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "DELETING")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getAnnotationStore
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getAnnotationStore(_:logger:)``.
    ///
    /// - Parameters:
    ///   - name: The store's name.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationStoreDeleted(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetAnnotationStoreRequest(
            name: name
        )
        try await self.waitUntilAnnotationStoreDeleted(input, logger: logger)
    }

    /// Waiter for operation ``getAnnotationStoreVersion(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationStoreVersionCreated(
        _ input: GetAnnotationStoreVersionRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetAnnotationStoreVersionRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "ACTIVE")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "CREATING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "UPDATING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getAnnotationStoreVersion
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getAnnotationStoreVersion(_:logger:)``.
    ///
    /// - Parameters:
    ///   - name:  The name given to an annotation store version to distinguish it from others.
    ///   - versionName:  The name given to an annotation store version to distinguish it from others.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationStoreVersionCreated(
        name: String,
        versionName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetAnnotationStoreVersionRequest(
            name: name, 
            versionName: versionName
        )
        try await self.waitUntilAnnotationStoreVersionCreated(input, logger: logger)
    }

    /// Waiter for operation ``getAnnotationStoreVersion(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationStoreVersionDeleted(
        _ input: GetAnnotationStoreVersionRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetAnnotationStoreVersionRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "DELETED")),
                .init(state: .success, matcher: AWSErrorCodeMatcher("ResourceNotFoundException")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "DELETING")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getAnnotationStoreVersion
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getAnnotationStoreVersion(_:logger:)``.
    ///
    /// - Parameters:
    ///   - name:  The name given to an annotation store version to distinguish it from others.
    ///   - versionName:  The name given to an annotation store version to distinguish it from others.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilAnnotationStoreVersionDeleted(
        name: String,
        versionName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetAnnotationStoreVersionRequest(
            name: name, 
            versionName: versionName
        )
        try await self.waitUntilAnnotationStoreVersionDeleted(input, logger: logger)
    }

    /// Waiter for operation ``getReadSetActivationJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReadSetActivationJobCompleted(
        _ input: GetReadSetActivationJobRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetReadSetActivationJobRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "COMPLETED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "SUBMITTED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "IN_PROGRESS")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "CANCELLING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "CANCELLED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "COMPLETED_WITH_FAILURES")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getReadSetActivationJob
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getReadSetActivationJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The job's ID.
    ///   - sequenceStoreId: The job's sequence store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReadSetActivationJobCompleted(
        id: String,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetReadSetActivationJobRequest(
            id: id, 
            sequenceStoreId: sequenceStoreId
        )
        try await self.waitUntilReadSetActivationJobCompleted(input, logger: logger)
    }

    /// Waiter for operation ``getReadSetExportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReadSetExportJobCompleted(
        _ input: GetReadSetExportJobRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetReadSetExportJobRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "COMPLETED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "SUBMITTED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "IN_PROGRESS")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "CANCELLING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "CANCELLED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "COMPLETED_WITH_FAILURES")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getReadSetExportJob
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getReadSetExportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The job's ID.
    ///   - sequenceStoreId: The job's sequence store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReadSetExportJobCompleted(
        id: String,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetReadSetExportJobRequest(
            id: id, 
            sequenceStoreId: sequenceStoreId
        )
        try await self.waitUntilReadSetExportJobCompleted(input, logger: logger)
    }

    /// Waiter for operation ``getReadSetImportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReadSetImportJobCompleted(
        _ input: GetReadSetImportJobRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetReadSetImportJobRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "COMPLETED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "SUBMITTED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "IN_PROGRESS")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "CANCELLING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "CANCELLED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "COMPLETED_WITH_FAILURES")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getReadSetImportJob
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getReadSetImportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The job's ID.
    ///   - sequenceStoreId: The job's sequence store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReadSetImportJobCompleted(
        id: String,
        sequenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetReadSetImportJobRequest(
            id: id, 
            sequenceStoreId: sequenceStoreId
        )
        try await self.waitUntilReadSetImportJobCompleted(input, logger: logger)
    }

    /// Waiter for operation ``getReferenceImportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReferenceImportJobCompleted(
        _ input: GetReferenceImportJobRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetReferenceImportJobRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "COMPLETED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "SUBMITTED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "IN_PROGRESS")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "CANCELLING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "CANCELLED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "COMPLETED_WITH_FAILURES")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getReferenceImportJob
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getReferenceImportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The job's ID.
    ///   - referenceStoreId: The job's reference store ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReferenceImportJobCompleted(
        id: String,
        referenceStoreId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetReferenceImportJobRequest(
            id: id, 
            referenceStoreId: referenceStoreId
        )
        try await self.waitUntilReferenceImportJobCompleted(input, logger: logger)
    }

    /// Waiter for operation ``getRun(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilRunCompleted(
        _ input: GetRunRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetRunRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "COMPLETED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "PENDING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "STARTING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "RUNNING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "STOPPING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getRun
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getRun(_:logger:)``.
    ///
    /// - Parameters:
    ///   - export: The run's export format.
    ///   - id: The run's ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilRunCompleted(
        export: [RunExport]? = nil,
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetRunRequest(
            export: export, 
            id: id
        )
        try await self.waitUntilRunCompleted(input, logger: logger)
    }

    /// Waiter for operation ``getRun(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilRunRunning(
        _ input: GetRunRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetRunRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "RUNNING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "PENDING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "STARTING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "CANCELLED")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getRun
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getRun(_:logger:)``.
    ///
    /// - Parameters:
    ///   - export: The run's export format.
    ///   - id: The run's ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilRunRunning(
        export: [RunExport]? = nil,
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetRunRequest(
            export: export, 
            id: id
        )
        try await self.waitUntilRunRunning(input, logger: logger)
    }

    /// Waiter for operation ``getRunTask(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilTaskCompleted(
        _ input: GetRunTaskRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetRunTaskRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "COMPLETED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "PENDING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "STARTING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "RUNNING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "STOPPING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getRunTask
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getRunTask(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The workflow run ID.
    ///   - taskId: The task's ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilTaskCompleted(
        id: String,
        taskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetRunTaskRequest(
            id: id, 
            taskId: taskId
        )
        try await self.waitUntilTaskCompleted(input, logger: logger)
    }

    /// Waiter for operation ``getRunTask(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilTaskRunning(
        _ input: GetRunTaskRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetRunTaskRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "RUNNING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "PENDING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "STARTING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "CANCELLED")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getRunTask
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getRunTask(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The workflow run ID.
    ///   - taskId: The task's ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilTaskRunning(
        id: String,
        taskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetRunTaskRequest(
            id: id, 
            taskId: taskId
        )
        try await self.waitUntilTaskRunning(input, logger: logger)
    }

    /// Waiter for operation ``getVariantImportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilVariantImportJobCreated(
        _ input: GetVariantImportRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetVariantImportRequest, _>(
            acceptors: [
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "SUBMITTED")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "IN_PROGRESS")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "CANCELLED")),
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "COMPLETED")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getVariantImportJob
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getVariantImportJob(_:logger:)``.
    ///
    /// - Parameters:
    ///   - jobId: The job's ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilVariantImportJobCreated(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetVariantImportRequest(
            jobId: jobId
        )
        try await self.waitUntilVariantImportJobCreated(input, logger: logger)
    }

    /// Waiter for operation ``getVariantStore(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilVariantStoreCreated(
        _ input: GetVariantStoreRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetVariantStoreRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "ACTIVE")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "CREATING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "UPDATING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getVariantStore
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getVariantStore(_:logger:)``.
    ///
    /// - Parameters:
    ///   - name: The store's name.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilVariantStoreCreated(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetVariantStoreRequest(
            name: name
        )
        try await self.waitUntilVariantStoreCreated(input, logger: logger)
    }

    /// Waiter for operation ``getVariantStore(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilVariantStoreDeleted(
        _ input: GetVariantStoreRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetVariantStoreRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "DELETED")),
                .init(state: .success, matcher: AWSErrorCodeMatcher("ResourceNotFoundException")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "DELETING")),
            ],
            minDelayTime: .seconds(30),
            maxDelayTime: .seconds(600),
            command: self.getVariantStore
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getVariantStore(_:logger:)``.
    ///
    /// - Parameters:
    ///   - name: The store's name.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilVariantStoreDeleted(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetVariantStoreRequest(
            name: name
        )
        try await self.waitUntilVariantStoreDeleted(input, logger: logger)
    }

    /// Waiter for operation ``getWorkflow(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilWorkflowActive(
        _ input: GetWorkflowRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetWorkflowRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "ACTIVE")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "CREATING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "UPDATING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
            ],
            minDelayTime: .seconds(3),
            maxDelayTime: .seconds(30),
            command: self.getWorkflow
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getWorkflow(_:logger:)``.
    ///
    /// - Parameters:
    ///   - export: The export format for the workflow.
    ///   - id: The workflow's ID.
    ///   - type: The workflow's type.
    ///   - workflowOwnerId: The ID of the workflow owner.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilWorkflowActive(
        export: [WorkflowExport]? = nil,
        id: String,
        type: WorkflowType? = nil,
        workflowOwnerId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetWorkflowRequest(
            export: export, 
            id: id, 
            type: type, 
            workflowOwnerId: workflowOwnerId
        )
        try await self.waitUntilWorkflowActive(input, logger: logger)
    }

    /// Waiter for operation ``getWorkflowVersion(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilWorkflowVersionActive(
        _ input: GetWorkflowVersionRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetWorkflowVersionRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "ACTIVE")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "CREATING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("status", expected: "UPDATING")),
                .init(state: .failure, matcher: try! JMESPathMatcher("status", expected: "FAILED")),
            ],
            minDelayTime: .seconds(3),
            maxDelayTime: .seconds(30),
            command: self.getWorkflowVersion
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getWorkflowVersion(_:logger:)``.
    ///
    /// - Parameters:
    ///   - export: The export format for the workflow.
    ///   - type: The workflow's type.
    ///   - versionName: The workflow version name.
    ///   - workflowId: The workflow's ID. The workflowId is not the UUID.
    ///   - workflowOwnerId: The 12-digit account ID of the workflow owner. The workflow owner ID can be retrieved using the GetShare API operation. If you are the workflow owner, you do not need to include this ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilWorkflowVersionActive(
        export: [WorkflowExport]? = nil,
        type: WorkflowType? = nil,
        versionName: String,
        workflowId: String,
        workflowOwnerId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetWorkflowVersionRequest(
            export: export, 
            type: type, 
            versionName: versionName, 
            workflowId: workflowId, 
            workflowOwnerId: workflowOwnerId
        )
        try await self.waitUntilWorkflowVersionActive(input, logger: logger)
    }
}
